【最大权闭合图】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=;
 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=;
 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()-,});
 }

 void Topology()
 {
     memset(usable,,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]=;
         if (score[head]>) ans+=score[head];
         for (int i=;i<rE[head].size();i++)
         {
             int to=rE[head][i];
             into[to]--;
             if (!into[to]) que.push(to);
         }
     }
 }

 bool bfs()
 {
     memset(dis,-,sizeof(dis));
     queue<int> que;
     while (!que.empty()) que.pop();
     que.push(S);
     dis[S]=;
     while (!que.empty())
     {
         int head=que.front();que.pop();
         if (head==T) return true;    //首次抵达T即可返回，不需要整张图全部分层
         for (int i=;i<E[head].size();i++)
         {
             node tmp=E[head][i];
             if (dis[tmp.to]==- && tmp.cap && usable[tmp.to])
             {
                 dis[tmp.to]=dis[head]+;
                 que.push(tmp.to);
             }
         }
     }
     return false;
 }

 int dfs(int s,int e,int f)
 {
     if (s==e) return f;
     int ret=;
     for (int i=;i<E[s].size();i++)
     {
         node &tmp=E[s][i];
         if (dis[tmp.to]==dis[s]+ && tmp.cap)
         {
             int delta=dfs(tmp.to,e,min(f,tmp.cap));
             if (delta>)
             {
                 tmp.cap-=delta;
                 E[tmp.to][tmp.pos].cap+=delta;
                 f-=delta;
                 ret+=delta;
                 if (f==) return ret;
             }
             else dis[tmp.to]=-;//注意一下这里要清为-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=;i<=n;i++)
         for (int j=;j<=m;j++)
         {
             int w,fr=(i-)*m+j;
             scanf("%d%d",&score[fr],&w);
             if (score[fr]>) addedge(S,fr,score[fr]);
                 else if (score[fr]<) addedge(fr,T,-score[fr]);
             for (int k=;k<=w;k++)
             {
                 int r,c;
                 scanf("%d%d",&r,&c);
                 r++;c++;
                 int to=(r-)*m+c;
                 addedge(to,fr,INF);
             }
             if (j!=m) addedge(fr,fr+,INF);
         }
 }

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