【NOI 2009】植物大战僵尸

【题目】

传送门

题目描述：

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 的进攻方案，选择进攻哪些植物以及进攻的顺序，从而获得最大的能源收入。

输入格式：

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

输出格式：

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

样例数据：

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

输出
25

备注：

【样例说明】
在样例中, 植物 P1,1 可以攻击位置 (0,0) , P2,0 可以攻击位置 (2,1)。

一个方案为，首先进攻 P1,1, P0,1，此时可以攻击 P0,0 。共得到能源收益为 (-5)+20+10=25。注意, 位置 (2,1) 被植物 P2,0 保护，所以无法攻击第 2 行中的任何植物。

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

【分析】

贼长的题目描述。。。

对于每个植物，都向保护它的植物连边，表示要吃掉它，必须先吃掉保护它的植物

那么要连边的话有以下两种情况：

1. 一个植物能攻击到的所有位置上的植物要向它连边
2. 一行中左边的植物要向右边的植物连边

连完边之后，就是一个典型的最大权闭合子图模型，网络流求解即可

注意以下的坑点：

1. 虽然点数不多，最多 600 个，但连出来的边可能有很多，数组要开大一点
2. 图中可能会出现环，即几种植物互相保护，这时肯定一颗植物都吃不掉，我们用拓扑排序排除掉这种情况即可

【代码】

#include<bits/stdc++.h>
using namespace std;
const int N=605,M=1e6+5,inf=0x3f3f3f3f;
int n,m,S,T,t=1;
int d[N],f[N],in[N],score[N],first[N],v[M],w[M],nxt[M];
bool flag[N];
void add(int x,int y,int z){
	nxt[++t]=first[x],first[x]=t,v[t]=y,w[t]=z;
	nxt[++t]=first[y],first[y]=t,v[t]=x,w[t]=0;
}
void topsort(){
	stack<int>stk;
	for(int i=1;i<=n*m;++i)
		if(!in[i])  stk.push(i);
	while(!stk.empty()){
		int x=stk.top();stk.pop();
		for(int i=first[x];i;i=nxt[i])
			if(!(--in[v[i]]))  stk.push(v[i]);
		flag[x]=true;
	}
}
queue<int>q;
bool bfs(){
	memset(d,-1,sizeof(d));
	memcpy(f,first,sizeof(f));
	d[S]=0,q.push(S);
	while(!q.empty()){
		int x=q.front();q.pop();
		for(int i=f[x];i;i=nxt[i]){
			int to=v[i];
			if(w[i]&&flag[to]&&d[to]==-1)  d[to]=d[x]+1,q.push(to);
		}
	}
	return d[T]!=-1;
}
int dinic(int x,int flow){
	if(x==T)  return flow;
	int delta,ans=0;
	for(int &i=f[x];i;i=nxt[i]){
		int to=v[i];
		if(w[i]&&flag[to]&&d[to]==d[x]+1){
			delta=dinic(to,min(flow,w[i]));
			w[i]-=delta,w[i^1]+=delta,flow-=delta,ans+=delta;
			if(!flow)  return ans;
		}
	}
	return ans;
}
int main(){
	scanf("%d%d",&n,&m);
	S=0,T=n*m+1;
	for(int i=1;i<=n;++i){
		for(int j=1;j<=m;++j){
			int id=(i-1)*m+j,x,y,attack;
			scanf("%d%d",&score[id],&attack);
			while(attack--){
				scanf("%d%d",&x,&y);
				add(x*m+y+1,id,inf),in[x*m+y+1]++;
			}
			if(j!=m)  add(id,id+1,inf),in[id]++;
		}
	}
	topsort(),flag[S]=flag[T]=true;
	int ans=0;
	for(int i=1;i<=n*m;++i){
		if(flag[i]){
			if(score[i]<0)  add(i,T,-score[i]);
			else  add(S,i,score[i]),ans+=score[i];
		}
	}
	while(bfs())  ans-=dinic(S,inf);
	printf("%d",ans);
	return 0;
}