题目地址：洛谷：【P2805】[NOI2009]植物大战僵尸 – 洛谷、BZOJ：Problem 1565. — [NOI2009]植物大战僵尸

题目描述

Plants vs. Zombies（PVZ）是最近十分风靡的一款小游戏。Plants（植物）和Zombies（僵尸）是游戏的主角，其中Plants防守，而Zombies进攻。该款游戏包含多种不同的挑战系列，比如Protect Your Brain、Bowling等等。其中最为经典的，莫过于玩家通过控制Plants来防守Zombies的进攻，或者相反地由玩家通过控制Zombies对Plants发起进攻。
现在，我们将要考虑的问题是游戏中Zombies对Plants的进攻，请注意，本题中规则与实际游戏有所不同。游戏中有两种角色，Plants和Zombies，每个Plant有一个攻击位置集合，它可以对这些位置进行保护；而Zombie进攻植物的方式是走到植物所在的位置上并将其吃掉。
游戏的地图可以抽象为一个N行M列的矩阵，行从上到下用0到N–1编号，列从左到右用0到M–1编号；在地图的每个位置上都放有一个Plant，为简单起见，我们把位于第r行第c列的植物记为Pr, c。
Plants分很多种，有攻击类、防守类和经济类等等。为了简单的描述每个Plant，定义Score和Attack如下：
Score[Pr, c]
Zombie击溃植物Pr, c可获得的能源。若Score[Pr, c]为非负整数，则表示击溃植物Pr, c可获得能源Score[Pr, c]，若为负数表示击溃Pr, c需要付出能源 -Score[Pr, c]。
Attack[Pr, c]
植物Pr, c能够对Zombie进行攻击的位置集合。
Zombies必须从地图的右侧进入，且只能沿着水平方向进行移动。Zombies攻击植物的唯一方式就是走到该植物所在的位置并将植物吃掉。因此Zombies的进攻总是从地图的右侧开始。也就是说，对于第r行的进攻，Zombies必须首先攻击Pr, M-1；若需要对Pr, c（0≤c<M-1）攻击，必须将Pr,M-1, Pr, M-2 … Pr, c+1先击溃，并移动到位置(r, c)才可进行攻击。
在本题的设定中，Plants的攻击力是无穷大的，一旦Zombie进入某个Plant的攻击位置，该Zombie会被瞬间消灭，而该Zombie没有时间进行任何攻击操作。因此，即便Zombie进入了一个Plant所在的位置，但该位置属于其他植物的攻击位置集合，则Zombie会被瞬间消灭而所在位置的植物则安然无恙（在我们的设定中，Plant的攻击位置不包含自身所在位置，否则你就不可能击溃它了）。
Zombies的目标是对Plants的阵地发起进攻并获得最大的能源收入。每一次，你可以选择一个可进攻的植物进行攻击。本题的目标为，制定一套Zombies的进攻方案，选择进攻哪些植物以及进攻的顺序，从而获得最大的能源收入。

题意简述

你在玩植物大战僵尸游戏，你操控僵尸破坏植物，破坏一棵植物要么付出代价要么获得收益，分别以正负权体现。植物的攻击力无穷，也就是说，当僵尸刚进入它能攻击的格子中时会被瞬间干掉；僵尸的攻击力也无穷，也就是说它没被干掉的时候能瞬间干掉一棵植物。求一种进攻方法，使得获得的权值最大。

输入输出格式

输入格式：
输入文件pvz.in的第一行包含两个整数N, M，分别表示地图的行数和列数。
接下来N×M行描述每个位置上植物的信息。第r×M + c + 1行按照如下格式给出植物Pr, c的信息：第一个整数为Score[Pr, c], 第二个整数为集合Attack[Pr, c]中的位置个数w，接下来w个位置信息（r’, c’），表示Pr, c可以攻击位置第r’ 行第c’ 列。

输出格式：
输出文件pvz.out仅包含一个整数，表示可以获得的最大能源收入。注意，你也可以选择不进行任何攻击，这样能源收入为0。

输入输出样例

输入样例#1：

3 2
10 0
20 0
-10 0
-5 1 0 0
100 1 2 1
100 0

输出样例#1：

25

说明

约20%的数据满足1 ≤ N, M ≤ 5；
约40%的数据满足1 ≤ N, M ≤ 10；
约100%的数据满足1 ≤ N ≤ 20，1 ≤ M ≤ 30，-10000 ≤ Score ≤ 10000

题解

首先，这是一个最大权闭合子图的模型，即，建立源→负权点，正权点→汇，保护点→被保护点的网络，其中源汇连边边权为点权绝对值，保护关系边权无限。这样，正权和-最小割就是答案。但是如果正负权点和源汇的建边关系反过来了会WA，这是由于一个正权点保护一个负权点显然是不优的，这些边的存在没有意义，更应该让负权点→正权点的边参与到流中。
信心满满的你写了一个Dinic，然后发现不对劲，这个图上有环！注意到本题提供了一个隐藏条件，即一个植物也可以保护它后面的植物，如果它后面的一个植物也保护了它，那它就无敌了。我们拓扑找环，然后把环上的点连同这些点可以到达的点全删了，然后把剩下的图当网络跑最大流就是正解。

代码

// Code by KSkun, 2018/7
#include <cstdio>
#include <cctype>
#include <cstring>

#include <algorithm>
#include <queue>

typedef long long LL;

inline char fgc() {
    static char buf[100000], *p1 = buf, *p2 = buf;
    return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
        ? EOF : *p1++;
}

inline LL readint() {
    register LL res = 0, neg = 1; register char c = fgc();
    for(; !isdigit(c); c = fgc()) if(c == '-') neg = -1;
    for(; isdigit(c); c = fgc()) res = res * 10 + c - '0';
    return res * neg;
}

const int MAXN = 605, INF = 1e9;

int n, m;

struct Edge {
    int to, cap, nxt;
} gra[1000005], gra2[1000005];
int head[MAXN], head2[MAXN], deg[MAXN], tot, tot2;

inline void addedge(int u, int v, int cap) {
    gra[tot] = Edge {v, cap, head[u]}; head[u] = tot++;
    gra[tot] = Edge {u, 0, head[v]}; head[v] = tot++;
}

inline void addedge2(int u, int v) {
    gra2[tot2] = Edge {v, 0, head2[u]}; head2[u] = tot2++;
    deg[v]++;
}

bool del[MAXN];

void dfs_del(int u) {
    del[u] = true;
    for(int i = head2[u]; ~i; i = gra2[i].nxt) {
        int v = gra2[i].to;
        if(!del[v]) dfs_del(v);
    }
}

inline void toposort() {
    std::queue<int> que;
    for(int i = 1; i <= n * m; i++) {
        if(!deg[i]) que.push(i);
        else del[i] = true;
    }
    while(!que.empty()) {
        int u = que.front(); que.pop(); del[u] = false;
        for(int i = head2[u]; ~i; i = gra2[i].nxt) {
            int v = gra2[i].to;
            if(!--deg[v]) que.push(v);
        }
    }
    for(int i = 1; i <= n * m; i++) {
        if(del[i]) dfs_del(i);
    }
}

int level[MAXN];

inline bool bfs(int s, int t) {
    memset(level, -1, sizeof(level));
    std::queue<int> que;
    que.push(s); level[s] = 1;
    while(!que.empty()) {
        int u = que.front(); que.pop();
        for(int i = head[u]; ~i; i = gra[i].nxt) {
            int v = gra[i].to;
            if(level[v] == -1 && gra[i].cap) {
                level[v] = level[u] + 1;
                if(v == t) return true;
                que.push(v);
            }
        }
    }
    return level[t] != -1;
}

int cur[MAXN];

int dfs(int u, int t, int left) {
    if(u == t || !left) return left;
    int flow = 0;
    for(int &i = cur[u]; ~i; i = gra[i].nxt) {
        int v = gra[i].to;
        if(level[v] == level[u] + 1 && gra[i].cap) {
            int d = dfs(v, t, std::min(left, gra[i].cap));
            if(d) {
                gra[i].cap -= d; gra[i ^ 1].cap += d;
                flow += d; left -= d;
                if(!left) break;
            }
        }
    }
    return flow;
}

inline int dinic(int s, int t) {
    int flow = 0;
    while(bfs(s, t)) {
        memcpy(cur, head, sizeof(head));
        int f;
        while(f = dfs(s, t, INF)) flow += f;
    }
    return flow;
}

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

int w[MAXN], S, T;

int main() {
    memset(head, -1, sizeof(head));
    memset(head2, -1, sizeof(head2));
    n = readint(); m = readint(); S = n * m + 1; T = S + 1;
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            w[id(i, j)] = readint();
            int t = readint();
            while(t--) {
                int x = readint() + 1, y = readint() + 1;
                addedge2(id(i, j), id(x, y));
            }
        }
    }
    for(int i = 1; i <= n; i++) {
        for(int j = 2; j <= m; j++) {
            addedge2(id(i, j), id(i, j - 1));
        }
    }
    toposort();
    int sum = 0;
    for(int i = 1; i <= n * m; i++) {
        if(del[i]) continue;
        if(w[i] > 0) {
            sum += w[i]; addedge(i, T, w[i]);
        } else {
            addedge(S, i, -w[i]);
        }
        for(int j = head2[i]; ~j; j = gra2[j].nxt) {
            int v = gra2[j].to;
            addedge(i, v, INF);
        }
    }
    printf("%d", sum - dinic(S, T));
    return 0;
}