洛谷P2805 植物大战僵尸

题意：给你一张图，每个节点保护若干节点。

当一个节点不被保护的时候，你就可以gay掉它。

gay每个节点都有收益(可能为负)，求最大总收益。

解：首先发现是一个最大权闭合子图。

把保护关系变成被保护，那么gay每个节点就必须gay每个保护它的节点。

然后发现有个小问题：有环。

于是我们tarjan求强连通分量然后删点。最后最大权闭合子图。

这里我删点删的十分暴力......(反正点不多)

注意：删点的时候，如果它权值为正，要在sum里面减去它的权值。

#include <cstdio>
#include <algorithm>
#include <queue>
#include <cstring>
#include <stack>

const int N = 1010, M = 1000010, INF = 0x3f3f3f3f;

struct Edge {
    int nex, v, c;
}edge[M << 1], _edge[M]; int top = 1, _top;

int e[N], d[N], _e[N];
std::queue<int> Q;
std::stack<int> S;
int dfn[N], low[N], num, fr[N], scc_cnt, scc_siz[N], vis[N], val[N], sum;

void tarjan(int x) {
    dfn[x] = low[x] = ++num;
    S.push(x);
    for(int i = _e[x]; i; i = _edge[i].nex) {
        int y = _edge[i].v;
        if(!dfn[y]) {
            tarjan(y);
            low[x] = std::min(low[x], low[y]);
        }
        else if(!fr[y]) {
            low[x] = std::min(low[x], dfn[y]);
        }
    }
    if(low[x] == dfn[x]) {
        scc_cnt++;
        int y;
        do {
            y = S.top();
            S.pop();
            fr[y] = scc_cnt;
            scc_siz[scc_cnt]++;
        } while(y != x);
    }
    return;
}

inline void add(int x, int y, int z) {
    top++;
    edge[top].v = y;
    edge[top].c = z;
    edge[top].nex = e[x];
    e[x] = top;

    top++;
    edge[top].v = x;
    edge[top].c = 0;
    edge[top].nex = e[y];
    e[y] = top;
    return;
}

inline void _add(int x, int y) {
    _top++;
    _edge[_top].v = y;
    _edge[_top].nex = _e[x];
    _e[x] = _top;
    return;
}

void del(int x) {
    vis[x] = 1;
    if(val[x] > 0) {
        sum -= val[x];
    }
    for(int i = e[x]; i; i = edge[i].nex) {
        edge[i].c = edge[i ^ 1].c = 0;
    }
    for(int i = _e[x]; i; i = _edge[i].nex) {
        int y = _edge[i].v;
        if(!vis[y]) {
            del(y);
        }
    }
    e[x] = _e[x] = 0;
    return;
}

inline bool BFS(int s, int t) {
    memset(d, 0, sizeof(d));
    d[s] = 1;
    Q.push(s);
    while(!Q.empty()) {
        int x = Q.front();
        Q.pop();
        for(int i = e[x]; i; i = edge[i].nex) {
            int y = edge[i].v;
            if(!edge[i].c || d[y]) {
                continue;
            }
            d[y] = d[x] + 1;
            Q.push(y);
        }
    }
    return d[t];
}

int DFS(int x, int t, int maxF) {
    if(x == t) {
        return maxF;
    }
    int ans = 0;
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(!edge[i].c || d[x] + 1 != d[y]) {
            continue;
        }
        int temp = DFS(y, t, std::min(edge[i].c, maxF - ans));
        if(!temp) {
            d[y] = INF;
        }
        ans += temp;
        edge[i].c -= temp;
        edge[i ^ 1].c += temp;
        if(ans == maxF) {
            break;
        }
    }
    return ans;
}

inline int solve(int s, int t) {
    int ans = 0;
    while(BFS(s, t)) {
        ans += DFS(s, t, INF);
    }
    return ans;
}

int m;
inline int id(int x, int y) {
    return (x - 1) * m + y;
}

int main() {

    int n;
    scanf("%d%d", &n, &m);
    int s = n * m + 1, t = n * m + 2;
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            int x, y, z;
            scanf("%d", &x);
            val[id(i, j)] = x;
            if(x > 0) {
                add(s, id(i, j), x);
                sum += x;
            }
            else if(x < 0) {
                add(id(i, j), t, -x);
            }
            scanf("%d", &z);
            for(int k = 1; k <= z; k++) {
                scanf("%d%d", &x, &y);
                x++;
                y++;
                add(id(x, y), id(i, j), INF);
                _add(id(i, j), id(x, y));
            }
            if(j < m) {
                add(id(i, j), id(i, j + 1), INF);
                _add(id(i, j + 1), id(i, j));
            }
        }
    }
    for(int i = 1; i <= n * m; i++) {
        if(!dfn[i]) {
            tarjan(i);
        }
    }
    for(int i = 1; i <= n * m; i++) {
        if(scc_siz[fr[i]] > 1 && !vis[i]) {
            del(i);
        }
    }
    printf("%d", sum - solve(s, t));
    return 0;
}