[BZOJ1565][NOI2009]植物大战僵尸（最大权闭合子图）

原题链接：http://www.lydsy.com/JudgeOnline/problem.php?id=1565

【问题描述】
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

好题，转化模型很巧妙。

首先把问题转化为，在一个平面网格图上每一格都有植物，植物之间可以互相保护（即攻击范围），僵尸吃掉植物有收益，收益可正可负，求僵尸的最大收益。

发现有相互依赖的关系且有负权，那妥妥的最大权闭合子图啊！

建图的思路很简单，如果i保护j的话那么又i–>j建正无穷边，如果score[i]>0那么i–>ed建值为score[i]的边，如果socre[i]<0那么st–>i建值为-score[i]的边。

这里有一点，如果这样的植物互相保护关系成为一个环的话（也就是环中的植物你保护
我我保护你，大家都不会死），那他们就必定不会被吃掉，所以我们根本不用理他。为了判环我们再建一个图，跑一遍拓扑排序即可，拓扑排序如何判环请自行百度。

判环后建新图跑网络流即可，ans=正权和-最小割。
再说一下为什么要i向j连边：如果i保护j，i向j连inf边 ,要不然如果j到i连边的话，假如j在环里面，那么i的入度不为0，这里会判断为不建。但实际上是i保护j，j无法被吃掉对于i是没有影响的 ，所以这条还是要建的 。

code

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int maxn=510000;
const int INF=9999999;
struct node
{
    int x,y,c,d,next,other;
}a[maxn*2];int len,last[maxn];
int st,ed;
void ins(int x,int y,int c)
{
    int k1,k2;
    len++;k1=len;
    a[len].x=x;a[len].y=y;a[len].c=c;
    a[len].next=last[x];last[x]=len;
    len++;k2=len;
    a[len].x=y;a[len].y=x;a[len].c=0;
    a[len].next=last[y],last[y]=len;
    a[k1].other=k2;
    a[k2].other=k1;
}
int h[maxn],list[maxn*2],head,tail;
inline bool bfs()
{
    memset(h,0,sizeof(h)); h[st]=1;
    list[1]=st,head=1,tail=2;
    while(head!=tail)
    {
        int x=list[head];
        for(int k=last[x];k;k=a[k].next)
        {
            int y=a[k].y;
            if(a[k].c>0 && h[y]==0)
            {
                h[y]=h[x]+1;
                list[tail++]=y;
            }
        }
        head++;
    }
    if(h[ed]>0) return true;
    else return false;
}
inline int findflow(int x,int f)
{
    if(x==ed) return f;
    int s=0,t;
    for(int k=last[x];k;k=a[k].next)
    {
        int y=a[k].y;
        if(a[k].c>0 && h[y]==h[x]+1 && s<f)
        {
            t=findflow(y,min(f-s,a[k].c));
            s+=t; a[k].c-=t; a[a[k].other].c+=t;
            if(s==f) return s;
        }
    }
    if(s==0) h[x]=0;
    return s;
}
int dinic()
{
    int s=0;
    while(bfs())
    {
        s+=findflow(st,INF);
    }
    return s;
}
struct edge
{
    int x,y,next;
}e[maxn]; int len2,last2[maxn];
void eins(int x,int y){len2++;e[len2].x=x;e[len2].y=y;e[len2].next=last2[x];last2[x]=len2;}
bool v[maxn];
int ru[maxn];
int n,m;
inline int getnum(int x,int y){return x*m+y+1;}
void dfs(int x)
{
    v[x]=true;
    for(int k=last2[x];k;k=e[k].next)
    {
        int y=e[k].y;
        if(!v[y])
            dfs(y);
    }
}
void topsort()
{
    memset(v,false,sizeof(v));
    queue<int>q;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            int x=getnum(i,j);
            if(ru[x]==0)
            {
                q.push(x);
            }
            else v[x]=true;
        }
    }
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        v[x]=false;
        for(int k=last2[x];k;k=e[k].next)
        {
            int y=e[k].y;
            ru[y]--;
            if(ru[y]==0) q.push(y);
        }
    }
    for(int i=1;i<=n*m;i++)
        if(ru[i])//最后剩下来的是环 
            v[i]=true;
}
int score[maxn];
int main()
{
//  freopen("pvz.in","r",stdin);
//  freopen("pvz.out","w",stdout);
    scanf("%d%d",&n,&m);
    st=m*n+1,ed=st+1;
    memset(last2,0,sizeof(last2)); len2=0;
    memset(last,0,sizeof(last)); len=0;
    for(int i=0;i<n;i++)    
    {
        for(int j=0;j<m-1;j++)
        {
            eins(getnum(i,j+1),getnum(i,j));
            ru[getnum(i,j)]++;
        }
    }
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            scanf("%d",&score[getnum(i,j)]);
            int A;scanf("%d",&A);
            for(int k=1;k<=A;k++)
            {
                int x,y;scanf("%d%d",&x,&y);
                eins(getnum(i,j),getnum(x,y));
                ru[getnum(x,y)]++;
            }
        }
    }
    topsort();
    int ans=0;
    for(int i=1;i<=n*m;i++)
    {
        if(!v[i])
        {
            if(score[i]>0)
            {
                ans+=score[i];
                ins(i,ed,score[i]);
            }
            else ins(st,i,-score[i]);
            for(int k=last2[i];k;k=e[k].next)
            {
                int y=e[k].y;
                if(!v[y])
                    ins(i,y,INF); 
//  i保护j，i向j连inf边 ,要不然如果j到i连边的话，假如j在环里面，那么i的入度不为0，这里会判断为不建。
//  但实际上是i保护j，j无法被吃掉对于i是没有影响的 ，所以这条还是要建的 

            }
        }
    }
    int tt=dinic();
    printf("%d\n",ans-tt);
    return 0; 
}