BZOJ1565植物大战僵尸——最大权闭合图+Tarjan缩点

Description

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

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

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

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

Sample Output
25

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

---

我们可以明显的知道，如果想要干掉植物（x,y）则必须干掉（x,j）,j∈[y+1,m]。并且还得干掉所有保护它的植物。所以很明显，我们可以将植物建在一个图上，然后求该图的最大权闭合图即可。

---

什么是闭合图？

闭合图是一张图（有向图），图中每个点有点权，对于这张图，如果你要选点x，就必须选能被x连到连到的点。比如存在一条x→y的边，则选了x就必须选y。如果存在一条从y→x的边，则选了x不一定要选y，但选了y就一定得选x。

---

怎么求最大权闭合图？

我们可以先将原图中的所有正点权累加值sum。然后我们重新建图，设一个超级源点，与所有的正权点相连，边权为正权点的点权；再设一个超级汇点，与所有的负权点相连，边权为负权点的点权的绝对值。然后正权点负、权点之间的连通信息如原图（如原图正权点x到负权点y有一条边，我们就在现在建出的图中连上x→y），并将边权赋值为INF（极大）。这么建完图后，整张图就成为了一个网络，我们求出整张图的最大流（最小割），用sum减去最大流，剩下的值就是最大权闭合图的值。

这个方法的证明大家可以去搜索，我这里就讲讲感性的理解。对于正权点，如果与它相连的闭合图最终权值小于0，则它肯定是不选的。而这样它所连的负权边的绝对值大于它， 而这样表现出的最小割就是它自己，相当于减去它自己，也就是不选它。如果最终权值大于0，则负权边的绝对值之和较小，表现出的最小割就是负权边之和，减去这个就相当于选了正权点然后减去相连的负权点。

---

我们回到此题，很明显，我们在建图的时候将点（x,y）与点（x,y+1）相连，并将被（x,y）保护的点连到（x,y）上。然后跑出该图的最大权闭合图即可。

但是这里有个问题，就是可能该图会有环，有环意味着什么呢？我们可以举个例子，比如（x,y）保护（x,y+1），则这两个点形成了环。想要干掉（x,y）必须先干掉（x,y+1），但（x,y）又保护着（x,y+1），所以想干掉（x,y+1），又得先干掉（x,y）。这样形成环的结果就是谁都干不掉，这两棵植物都安全了。

因此我们要先判断环，环上的点肯定都舍弃了，并且还得舍弃连到环上的点的点。比如（x,y）在环上，（x,y-1）不在环上。但（x,y-1）也不能选，因为能从（x,y-1）到（x,y），相当于（x,y）干不掉，（x,y-1）也干不掉，但（x,y）又确实干不掉，所以（x,y-1）也得舍弃。同理如果一个在环上的点保护着点（x,y），则（x,y）也得舍弃。

所以我们自然就想到了Tarjan算法，我们用Tarjan求出每一个环，然后把这些环以及相关的点处理掉即可。

Code:

#include<bits/stdc++.h>
#define MAXN 800000
#define MAXM 700
#define INF 2e9
using namespace std;
int read(){
    char c;int x=0,y=1;while(c=getchar(),(c<'0'||c>'9')&&c!='-');
    if(c=='-') y=-1;else x=c-'0';while(c=getchar(),c>='0'&&c<='9')
    x=x*10+c-'0';return x*y;
}
struct node{
    int to,val;
}L[MAXN];
int head[MAXN],nxt[MAXN],dfn[MAXM],low[MAXM],sta[MAXM],vis[MAXM],che[MAXM],dis[MAXM],q[MAXN],val[MAXM];
int cnt,n,m,S,T,top,tim,ans,h,t,tot;
void add(int x,int y,int c){
    L[cnt]=(node){y,c};
    nxt[cnt]=head[x];head[x]=cnt;cnt++;
    L[cnt]=(node){x,0};
    nxt[cnt]=head[y];head[y]=cnt;cnt++;
}
void tarjan(int x){
    low[x]=++tim;dfn[x]=tim;
    sta[++top]=x;vis[x]=1;
    for(int i=head[x];i!=-1;i=nxt[i]){
        if(!L[i].val) continue;
        int to=L[i].to;
        if(to==T) continue;
        if(!dfn[to]) tarjan(to),low[x]=min(low[x],low[to]);
        else if(vis[to]) low[x]=min(low[x],dfn[to]);
    }
    if(low[x]==dfn[x]){
        if(sta[top]==x){
            vis[x]=0;top--;return;
        }
        int now=0;
        while(now!=x){
            now=sta[top];top--;vis[now]=0;
            if(val[now]>0&&!che[now]) tot-=val[now];che[now]=1;
        }
    }
}
int BFS(){
    memset(dis,0,sizeof(dis));dis[S]=1;
    h=t=0;q[++t]=S;
    while(h<t){
        int front=q[++h];
        for(int i=head[front];i!=-1;i=nxt[i]){
            int to=L[i].to;
            if(L[i].val&&!dis[to]&&!che[to]){
                q[++t]=to;
                dis[to]=dis[front]+1;
            }
        }
    }
    return dis[T];
}
int DFS(int now,int x){
    if(now==T) return x;
    int res=0;
    for(int i=head[now];i!=-1&&x;i=nxt[i]){
        int to=L[i].to;
        if(dis[to]==dis[now]+1&&L[i].val&&!che[to]){
            int fd=DFS(to,min(x,L[i].val));
            x-=fd;res+=fd;
            L[i].val-=fd;L[i^1].val+=fd;
        }
    }
    if(!res) dis[now]=-1;
    return res;
}
void dfs(int x){
    for(int i=head[x];i!=-1;i=nxt[i]){
        int to=L[i].to;
        if(!L[i].val&&!che[to]){
            che[to]=1;if(val[to]>0) tot-=val[to];
            dfs(to);
        }
    }
}
int main()
{
    memset(head,-1,sizeof(head));
    n=read();m=read();S=0;T=n*m+1;
    for(int i=1;i<=n;i++)
     for(int j=1;j<=m;j++){
        int x=read(),w=read(),pl=(i-1)*m+j;val[pl]=x;
        for(int i=1;i<=w;i++){
            int px=read(),py=read();
            if((px)*m+py+1==pl&&!che[pl]){
                che[pl]=1;if(val[pl]>0) tot-=val[pl];
             }
            add((px)*m+py+1,pl,INF);
         }
        if(x>=0) add(S,pl,x),tot+=x;
        else add(pl,T,-x); 
     }
    for(int i=1;i<=n*m;i++)
     if(i%m!=1) add(i-1,i,INF);
    for(int i=1;i<=n*m;i++)
      if(!dfn[i]) tarjan(i);
    for(int i=1;i<=n*m;i++)
      if(che[i]) dfs(i);
    while(BFS()) ans+=DFS(S,2e9);
    printf("%d",tot-ans);
    return 0;
}