[BZOJ 1565][NOI 2009]植物大战僵尸(Dinic最大流+拓扑排序)

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

orz题目太神。。。膝盖已经跪烂。。。。

这题需要我们建立起植物和植物之间复杂的保护关系，以及吃植物得到的损失和回报，因此要用最大流搞，建模太神奇了，跪跪跪。。。

首先我们建立源点和汇点，对于每个植物，如果吃它可以得到能源，在源点和它之间连一条边，容量为得到的能源数量。如果吃它要消耗能源，则在它和汇点之间建立一条边，边权为消耗的能源个数。

然后对于每个植物，将它和它的保护区域中的每个植物分别连一条边，容量为无穷大。

然后要注意，每一行的最后一个点要和下一行的第一个点连一条边，容量为无穷大，这样才能保证做好的图是联通的。

考虑到有可能有一些植物们可以相互保护，这样的话僵尸是吃不了它们的，这种情况下在图中这些植物会连成一个环，因此接着要拓扑排序，把图中所有的环都消去。

最后Dinic跑最大流，答案=图上所有不属于环的植物的权值-最大流

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <queue>

#define MAXE 500500
#define MAXV 650
#define INF 0x3f3f3f3f

using namespace std;

int ans=0,f[MAXV],S,T,n,m;
bool used[MAXV]; //used[i]=true表明点i没有被去除掉
int inDegree[MAXV]; //每个点的入度

//Start Of Graph Structure
struct edge
{
    int u,v,cap,next;
}edges[MAXE];

int head[MAXV],nCount=-1;

void AddEdge(int U,int V,int C)
{
    edges[++nCount].u=U;
    edges[nCount].v=V;
    edges[nCount].cap=C;
    edges[nCount].next=head[U];
    head[U]=nCount;
}

void add(int U,int V,int C)
{
    AddEdge(U,V,C);
    AddEdge(V,U,0);
    inDegree[U]++;
}
//End Of Graph Structure

//Start Of Topological Sort
void TopoSort()
{
    queue<int>q;
    while(!q.empty()) q.pop();
    for(int i=S;i<=T;i++)
        if(!inDegree[i])
            q.push(i);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        used[u]=true;
        if(f[u]>0)
            ans+=f[u];
        for(int p=head[u];p!=-1;p=edges[p].next)
        {
            int v=edges[p].v;
            if(p&1)
            {
                inDegree[v]--;
                if(!inDegree[v])
                    q.push(v);
            }
        }
    }
}
//End Of Topological Sort

//Start Of Dinic Max-flow Algorithm
int layer[MAXV]; //bfs分出的层

bool CountLayer()
{
    memset(layer,0,sizeof(layer));
    queue<int>q;
    while(!q.empty()) q.pop();
    q.push(S);
    layer[S]=1;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int p=head[u];p!=-1;p=edges[p].next)
        {
            int v=edges[p].v;
            if(!layer[v]&&edges[p].cap&&used[v])
            {
                layer[v]=layer[u]+1;
                q.push(v);
                if(v==T) return true;
            }
        }
    }
    return false;
}

int DFS(int u,int flow)
{
    int tmp=flow;
    if(u==T) return flow;
    for(int p=head[u];p!=-1;p=edges[p].next)
    {
        int v=edges[p].v;
        if(edges[p].cap&&layer[v]==layer[u]+1&&tmp)
        {
            int now=DFS(v,min(tmp,edges[p].cap));
            if(!now) layer[v]=0;
            tmp-=now;
            edges[p].cap-=now;
            edges[p^1].cap+=now;
        }
    }
    return flow-tmp;
}

int Dinic()
{
    int maxflow=0;
    while(CountLayer())
        maxflow+=DFS(S,INF);
    return maxflow;
}
//End Of Dinic Max-flow Algorithm

int main()
{
    memset(head,-1,sizeof(head));
    int x,y,r,c;
    scanf("%d%d",&m,&n);
    S=0,T=n*m+1;
    for(int i=1;i<=m*n;i++)
    {
        scanf("%d",&f[i]);
        if(f[i]>0) //吃该植物能得到能量
            add(S,i,f[i]);
        else //吃该植物要付出能量
            add(i,T,-f[i]);
        scanf("%d",&y); //攻击范围
        for(int j=1;j<=y;j++)
        {
            scanf("%d%d",&r,&c);
            add(r*n+c+1,i,INF); //从被保护的植物到该植物连一条容量无穷大的边
        }
        if(i%n)
            add(i,i+1,INF);
    }
    TopoSort();
    cout << ans-Dinic() << endl;
    return 0;
}