【最大权闭合图】BZOJ1565-[NOI2009]植物大战僵尸

害怕地发现我以前写的Dinic几乎都是有错的……？？！！！

【题目大意】

（以下摘自popoqqq大爷）给定一个m*n的草坪，每块草坪上的植物有两个属性：1.啃掉这个植物，获得收益x(可正可负)2.保护(r,c)点的植物不被啃掉。任何一个点的植物存活时，它左侧的所有植物都无法被攻击，求最大收益。

【思路】

首先我们很容易发现，植物存活有一个依赖关系，显然是一个最大权闭合图，即从被保护者指向保护者（简单来说，就是只有保护者被吃掉的情况下，被保护者才有可能被吃掉）。

注意，如果构成了一个环，则不会被吃掉；此外，当前点指向直接或间接指向一个环，也不可能被吃掉。

那么怎么删除环和指向环的节点呢？这里有一个拓扑排序常用的小技巧：

把所有边反向，从入度为0的点开始拓扑排序，能抵达的点便是保留的点。

顺便放一个拓扑排序的模板：

 1 void Topology()
 2 {
 3     memset(usable,0,sizeof(usable));
 4     queue<int> que;
 5     for (int i=S;i<=T;i++)
 6         if (!into[i]) que.push(i);
 7     while (!que.empty())
 8     {
 9         int head=que.front();que.pop();
10         usable[head]=1;
11         if (score[head]>0) ans+=score[head];
12         for (int i=0;i<rE[head].size();i++)
13         {
14             int to=rE[head][i];
15             into[to]--;
16             if (!into[to]) que.push(to); 
17         }
18     }
19 }

 【错误点】

 一开始建图的时候正向边反向边傻傻没分清……

2016/7/29修改：突然我以前写的Dinic都是错的我要爆炸了！现在又优化了一下，更正详见注释里面。至于优化前后的效率差距：

呃……

/*2016.7.29更正*/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#define S 0
#define T m*n+1
using namespace std;
const int MAXN=35;
struct node
{
    int to,pos,cap;
};
const int INF=0x7fffffff;
vector<int> rE[MAXN*MAXN];
vector<node> E[MAXN*MAXN]; 
int score[MAXN*MAXN];
int n,m,ans=0;
int usable[MAXN*MAXN],into[MAXN*MAXN];
int dis[MAXN*MAXN];

void addedge(int u,int v,int w)
{
    rE[v].push_back(u);
    into[u]++; 
    E[u].push_back((node){v,E[v].size(),w});
    E[v].push_back((node){u,E[u].size()-1,0}); 
}

void Topology()
{
    memset(usable,0,sizeof(usable));
    queue<int> que;
    for (int i=S;i<=T;i++)
        if (!into[i]) que.push(i);
    while (!que.empty())
    {
        int head=que.front();que.pop();
        usable[head]=1;
        if (score[head]>0) ans+=score[head];
        for (int i=0;i<rE[head].size();i++)
        {
            int to=rE[head][i];
            into[to]--;
            if (!into[to]) que.push(to); 
        }
    }
}

bool bfs()
{
    memset(dis,-1,sizeof(dis));
    queue<int> que;
    while (!que.empty()) que.pop(); 
    que.push(S);
    dis[S]=0;
    while (!que.empty())
    {
        int head=que.front();que.pop();
        if (head==T) return true;    //首次抵达T即可返回，不需要整张图全部分层 
        for (int i=0;i<E[head].size();i++)
        {
            node tmp=E[head][i];
            if (dis[tmp.to]==-1 && tmp.cap && usable[tmp.to])
            {
                dis[tmp.to]=dis[head]+1;
                que.push(tmp.to);
            }
        }
    }
    return false;
}
 
int dfs(int s,int e,int f)
{
    if (s==e) return f;
    int ret=0;
    for (int i=0;i<E[s].size();i++)
    {
        node &tmp=E[s][i];
        if (dis[tmp.to]==dis[s]+1 && tmp.cap)
        {
            int delta=dfs(tmp.to,e,min(f,tmp.cap));
            if (delta>0)
            {
                tmp.cap-=delta;
                E[tmp.to][tmp.pos].cap+=delta;
                f-=delta;
                ret+=delta;
                if (f==0) return ret;
            }
            else dis[tmp.to]=-1;//注意一下这里要清为-1，很重要★★★★★ 
        }
    } 
    return ret;
}
 
void dinic()
{
    while (bfs())
    {
        int f=dfs(S,T,INF);
        if (f) ans-=f;else break;
    }
}

void init()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++)
        {
            int w,fr=(i-1)*m+j;
            scanf("%d%d",&score[fr],&w);
            if (score[fr]>0) addedge(S,fr,score[fr]);
                else if (score[fr]<0) addedge(fr,T,-score[fr]);
            for (int k=1;k<=w;k++)
            {
                int r,c;
                scanf("%d%d",&r,&c);
                r++;c++;
                int to=(r-1)*m+c;
                addedge(to,fr,INF);
            }
            if (j!=m) addedge(fr,fr+1,INF);
        }
}

int main()
{
    init();
    Topology();
    dinic();
    printf("%d",ans);
    return 0;
}