网络流构图_洛谷P2805 [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

解题思路：
我就直接进入正题了，我们可以去的到一些正权值的点，得到这个收益可能我们需要付出一定的代价，这个代价可能是负的也可能是正的。所以我们可以让途中左边的点指向右边的点，被攻击的点指向攻击点，这样我们求出这张图的最大闭合子图的值就是最终的答案。但是，按照题目的意思，这张图中有一些点是不能够到达的，也就是存在环，无敌的点。所以在我们构造网络之前我们需要求构造出拓扑排序的图，筛选出可以到达的点，然后利用这些可以到达的点构建一张网络图，最后用 正的收益 - 最小割 就是最后的答案。

第一步构图：每个右边的点指向左边的点，然后让攻击的点指向各自对应被攻击的点。然后跑一边bfs就得到了所有可以到达的点。
第二步构图：在筛选出的点中，让所有左边的点指向对应右边的点，让主动攻击的点指向对应被攻击的点，边权全为 inf。 让源点s指向所有权值为正的点，边权为各自对应的点权；让所有点权为负的点指向汇点s，边权为对应点权的相反数。

最后跑一边最大流，让所有正权值之和 - maxflow，就是最后的答案。

注意点：
1.一个点可以攻击多个点！！！
2.注意初始化
3.注意第二次构图中所有的点都是可达的点

AC代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>

using namespace std;

const int N = 4005, M = 2e6;
const int inf = 0x3f3f3f3f;

int n, m, ans, s, t, maxflow;
int h[N], now[N], w[M], e[M], ne[M], idx;
int d[N], g[25][35];
bool vis[N];
vector<int> tmp[N]; 
int in[N];
int cnt;

inline int get(int i, int j) {
	return (i - 1) * m + j;
}

inline void add1(int a, int b) {
	e[idx] = b, ne[idx] = h[a], h[a] = idx ++; 
}

inline void add(int a, int b, int c) {
	e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
	e[idx] = a, w[idx] = 0, ne[idx] = h[b], h[b] = idx ++;
}

inline bool bfs(void) {
	queue<int> q;
	while(q.size()) q.pop();
	memset(d, 0, sizeof d);
	
	d[s] = 1; q.push(s);
	
	while(q.size()) {
		int u = q.front(); q.pop();
		
		for(int i = h[u]; i + 1; i = ne[i]) {
			int v = e[i];
			if(w[i] && !d[v]) {
				d[v] = d[u] + 1;
				q.push(v);
			}
		}
	}
	
	return d[t] != 0;
}

inline void topsort(void) {
	queue<int> q;
	while(q.size()) q.pop();
	
	for(int i = 1; i <= n * m; i ++)
		if(!in[i]) q.push(i), vis[i] = true;
	
	while(q.size()) {
		int u = q.front(); q.pop();
		
		for(int i = h[u]; i + 1; i = ne[i]) {
			int v = e[i];
			in[v] --;
			if(!in[v] && !vis[v]) {
				q.push(v);
				vis[v] = true;
			}
		}
	}
}

inline int dinic(int u, int flow) {
	if(u == t) return flow;
	
	int i;
	for(i = now[u]; i + 1; i = ne[i]) {
		now[u] = i;
		int v = e[i];
		if(d[v] == d[u] + 1 && w[i]) {
			int k = dinic(v, min(flow, w[i]));
			if(k) {
				w[i] -= k;
				w[i ^ 1] += k;
				return k;
			} else d[v] = 0;
		}
	}
	
	return 0;
}

int main(void) {
//	freopen("in.txt", "r", stdin);
	
	scanf("%d%d", &n, &m);
	
	//1.构建拓扑图，判断可以到达的点 
	memset(h, -1, sizeof h);
	s = n * m + 1, t = s + 1;  
	//记录攻击 与 被攻击 的点， 并且连接边 ; 右边的点  连接 左边的点 
	for(int i = 1; i <= n; i ++)
		for(int j = 1; j <= m; j ++) {
			int k; scanf("%d%d", &g[i][j], &k); cnt = 0;
			while(k --) {
				int a, b; scanf("%d%d", &a, &b); a ++; b ++;
				add1(get(i, j), get(a, b));
				tmp[get(i, j)].push_back(get(a, b));
				in[get(a, b)] ++;
			}
			
			if(j > 1) add1(get(i, j), get(i, j - 1)), in[get(i, j - 1)] ++;
		}
	
	//寻找可以到达的点 
	topsort();


	//2.构建网络, 求最大闭合子图 
	//初始化 
	memset(h, -1, sizeof h); idx = 0;
	memset(e, 0, sizeof e); 
	memset(ne,0, sizeof ne);
	
	//被攻击的点  连接   攻击的点
	for(int i = 1; i <= n * m; i ++) {
		if(!vis[i]) continue;
		int len = tmp[i].size();
		if(len == 0) continue;
		for(int j = 0; j < len; j ++) {
			int v = tmp[i][j];
			if(!vis[v]) continue;
			add(v, i, inf);
		}
	}
			
	//左边的点连接右边的点
	for(int i = 1; i <= n; i ++)
		for(int j = 1; j < m; j ++) {
			int a = get(i, j), b = get(i, j + 1);
			if(vis[a] && vis[b]) add(a, b, inf);
		}
	
	//让可以到达的点中的负点连接t， s 连接 正点 , 并且累计正权值 
	for(int i = 1; i <= n; i ++)
		for(int j = 1; j <= m; j ++)
			if(vis[get(i, j)])
				if(g[i][j] >= 0) add(s, get(i, j), g[i][j]), ans += g[i][j];
				else add(get(i, j), t, -g[i][j]);	 
	
	//跑网络流
	int flow; 
	while(bfs()) {
		memcpy(now, h, sizeof h);
		while(flow = dinic(s, inf)) ans -= flow;
	}
	
	printf("%d\n", ans);
		
	
//	fclose(stdin);
	return 0;			
}