Bzoj 1565: [NOI2009]植物大战僵尸 最大权闭合图,拓扑排序

题目: http://cojs.tk/cogs/problem/problem.php?pid=410

410. [NOI2009] 植物大战僵尸

★★★   输入文件：pvz.in   输出文件：pvz.out   简单对比
时间限制：2 s   内存限制：512 MB

【问题描述】

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。

【输入样例】

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

题解：

最大权闭合图+拓扑排序

首先，这道题中关于位置之间有依赖关系。比如在题目中要攻击(0,0)，必须先攻击(1,1)。还有先把靠右的吃掉，才能吃左侧的。

题中的 保护关系 和 先右后左关系 可以想到 最大权闭合图。（要吃掉某个 植物a 必须先吃掉 植物b(在a的右边或保护a的植物),我们要从a连边到b）

但是这道题中有环，我们可以在 反向边上跑拓扑序 来把 在环中 或 被环直接或间接指向 的点去除(这些植物一定不能吃掉)。

判环好像可以用传递闭包。。。

 #include<bits/stdc++.h>
 using namespace std;
 #define MAXN 620
 #define INF 1e9
 struct Ts
 {
     int begin,end,next;
 }ts[];
 struct node
 {
     int begin,end,value,next;
 }edge[];
 int cnt,cnt1,Head[MAXN],Head1[MAXN],Id[MAXN],q[MAXN],dis[MAXN],cur[MAXN],Score[MAXN],S,T,m,N,ans;
 bool use[MAXN];
 void addts(int bb,int ee)
 {
     Id[ee]++;
     ts[++cnt1].begin=bb;ts[cnt1].end=ee;ts[cnt1].next=Head1[bb];Head1[bb]=cnt1;
 }
 void addedge(int bb,int ee,int vv)
 {
     edge[++cnt].begin=bb;edge[cnt].end=ee;edge[cnt].value=vv;edge[cnt].next=Head[bb];Head[bb]=cnt;
 }
 void addedge1(int bb,int ee,int vv)
 {
     //Id[bb]++;
     addedge(bb,ee,vv);addedge(ee,bb,);
 }
 int read()
 {
     int s=,fh=;char ch=getchar();
     while(ch<''||ch>''){if(ch=='-')fh=-;ch=getchar();}
     while(ch>=''&&ch<=''){s=s*+(ch-'');ch=getchar();}
     return s*fh;
 }
 int xy(int x,int y){return (x-)*m+y;}
 void Toposort()
 {
     int head=,tail=,u,i,v;
     for(i=;i<=T;i++)if(Id[i]==)q[++tail]=i;
     while(head!=tail)
     {
         head++;if(head==)head=;
         u=q[head];use[u]=true;
         if(Score[u]>)ans+=Score[u];
         for(i=Head1[u];i!=-;i=ts[i].next)
         {
             v=ts[i].end;
             Id[v]--;
             if(Id[v]==)
             {
                 tail++;if(tail==)tail=;
                 q[tail]=v;
             }
         }
     }
 }
 int BFS()
 {
     int head,tail,i,u,v;
     head=;tail=;q[tail]=S;
     memset(dis,-,sizeof(dis));dis[S]=;
     while(head!=tail)
     {
         head++;if(head==)head=;
         u=q[head];
         for(i=Head[u];i!=-;i=edge[i].next)
         {
             v=edge[i].end;
             if(edge[i].value>&&dis[v]<&&use[v]==true)
             {
                 dis[v]=dis[u]+;
                 tail++;if(tail==)tail=;
                 q[tail]=v;
             }
         }
     }
     if(dis[T]<=)return ;
     else return ;
 }
 int Dfs(int u,int minflow)
 {
     int ans=,used=,i,v;
     if(u==T)return minflow;
     for(i=cur[u];i!=-;i=edge[i].next)
     {
         v=edge[i].end;
         if(edge[i].value>&&dis[v]==dis[u]+)
         {
             ans=minflow-used;
             ans=Dfs(v,min(ans,edge[i].value));
             edge[i].value-=ans;if(edge[i].value>)cur[u]=i;
             edge[i^].value+=ans;
             used+=ans;
             if(used==minflow)return minflow;
         }
     }
     if(used==)dis[u]=-;
     return used;
 }
 int Dinic()
 {
     int maxflow=,ans=,i;
     while(BFS()){for(i=;i<=T;i++)cur[i]=Head[i];ans=Dfs(S,INF);if(ans==)break;maxflow+=ans;}
     return maxflow;
 }
 int main()
 {
     //freopen("pvz.in","r",stdin);
     //freopen("pvz.out","w",stdout);
     int n,i,j,k,xy1,xy2,R,C,K;
     n=read();m=read();
     memset(Head,-,sizeof(Head));cnt=;
     memset(Head1,-,sizeof(Head1));cnt1=;
     N=xy(n,m);ans=;S=N+;T=S+;
     for(i=;i<=n;i++)
     {
         for(j=;j<=m;j++)
         {
             xy1=xy(i,j);
             Score[xy1]=read();
             if(Score[xy1]>){addedge1(S,xy1,Score[xy1]);addts(xy1,S);}
             else {addedge1(xy1,T,-Score[xy1]);addts(T,xy1);}
             K=read();
             for(k=;k<=K;k++)
             {
                 R=read();C=read();R++;C++;
                 xy1=xy(i,j);xy2=xy(R,C);
                 addts(xy1,xy2);
                 addedge1(xy2,xy1,INF);
             }
             if(j!=m){addedge1(xy(i,j),xy(i,j+),INF);addts(xy(i,j+),xy(i,j));}
         }
     }
     memset(use,false,sizeof(use));//标记能用的点(即 不在环中 或 不被环中的点所指向 或间接指向 的点).
     Toposort();
     printf("%d",ans-Dinic());
     fclose(stdin);
     fclose(stdout);
     return ;
 }