TYVJ 1452 最大权闭合图

若有向图G的子图V满足【V中顶点的所有出边均指向V内部顶点】，则称V是G的一个闭合子图。其中点权和最大的闭合子图称为有向图G的最大权闭合子图，简称最大权闭合图。

最大权闭合图的构图方法如下：建立源点S和汇点T，源点S连所有点权为正的点，容量为该点点权；其余点连汇点T，容量为点权绝对值，对于原图中的边<u,v>，连边<u,v>，容量+∞。

定理1：最大权闭合图的点权和 = 所有正权点权值和 - 最小割(最大流)。

定理2：上述网络的最小割包含：S到“不在最大权闭合图内的正权节点”的边 以及 “在最大权闭合图内的负权节点”到T的边。

定理2的推论：在残余网络中由源点S能够访问到的点，就构成一个点数最少的最大权闭合图。

以上引自：lyd神犇的博客~http://hi.baidu.com/lydrainbowcat/item/ee01570b259f17cc75cd3c65

　　　　以备自己复习时候看~

应用拓扑排序消环~ 

#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <cstdio>
#include <cstring>
//先去环再去反向边，不能先建反边再去环 
#define N 10010
#define M 2000100
#define INF 1e9

using namespace std;

int head[N],to[M],next[M],len[M];
int pto[M],phead[N],pnext[M],pin[N],pout[N],val[N];
int q[M*5],layer[N];
bool vis[N];
int n,cnt,pcnt,S,T,sum;

inline void padd(int u,int v)
{
    pto[pcnt]=v; pnext[pcnt]=phead[u]; phead[u]=pcnt++; 
    pin[v]++;
}

inline void add(int u,int v,int w)
{
    to[cnt]=v; len[cnt]=w; next[cnt]=head[u]; head[u]=cnt++;
    to[cnt]=u; len[cnt]=0; next[cnt]=head[v]; head[v]=cnt++;
}

inline void topsort()
{
    int h=1,t=1,sta;
    for(int i=1;i<=n;i++)
        if(pin[i]==0) q[t++]=i;
    while(h<t)
    {
        sta=q[h++];
        for(int i=phead[sta];~i;i=pnext[i])
        {
            pin[pto[i]]--;
            if(pin[pto[i]]==0) q[t++]=pto[i];
        }
    }
    for(int i=1;i<t;i++) vis[q[i]]=true;
}

inline void read()
{
    memset(head,-1,sizeof head); cnt=0;
    memset(phead,-1,sizeof phead); pcnt=0;
    scanf("%d",&n);
    S=0; T=n+1;
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d",&val[i],&pout[i]);
        for(int j=1,a;j<=pout[i];j++)
        {
            scanf("%d",&a);
            padd(a,i);
        }
    }
    topsort();
    for(int i=1;i<=n;i++)
        if(vis[i])
        {
            if(val[i]<0) add(i,T,-val[i]);
            else add(S,i,val[i]),sum+=val[i];
            for(int j=phead[i];~j;j=pnext[j])
                if(vis[pto[j]]) add(pto[j],i,INF);
        }
}

inline bool bfs()
{
    memset(layer,-1,sizeof layer);
    int h=1,t=2,sta;
    q[1]=S; layer[S]=0;
    while(h<t)
    {
        sta=q[h++];
        for(int i=head[sta];~i;i=next[i])
            if(len[i]&&layer[to[i]]<0)
            {
                layer[to[i]]=layer[sta]+1;
                q[t++]=to[i];
            }
    }
    return layer[T]!=-1;
}

inline int find(int u,int cur_flow)
{
    if(u==T) return cur_flow;
    int res=0,tmp;
    for(int i=head[u];~i&&res<cur_flow;i=next[i])
        if(len[i]&&layer[to[i]]==layer[u]+1)
        {
            tmp=find(to[i],min(cur_flow-res,len[i]));
            len[i]-=tmp; len[i^1]+=tmp; res+=tmp;
        }
    if(!res) layer[u]=-1;
    return res;
}

inline void go()
{
    int ans=0;
    while(bfs()) ans+=find(S,INF);
    printf("%d\n",sum-ans);
} 

int main()
{
    read();
    go();
    return 0;
}