BZOJ 2502 清理雪道 最小流

题目大意：给定一张拓扑图，求最少的链(可重复)使之覆盖所有的边
《妈妈我终于会最小流了系列 》
最小流做法如下：
建出可行流的模型，设原先的源汇为$SS$和$TT$，新加入的源汇为$S$和$T$
跑可行流，若$S$的某条出边不满流则无解
删除$S$和$T$的所有连边，设$TT-SS$这条边的流量为$x_1$，删除这条边
链接$S->TT$和$SS->T$，跑最大流，设最大流为$x_2$
那么$x_1-x_2$即为最小流
原理是跑可行流的时候可能多跑了一些，第二次最大流是为了将多跑的这些跑回来

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define M 110
#define S (M-1)
#define T (M-2)
#define SS (M-3)
#define TT (M-4)
#define INF 0x3f3f3f3f
using namespace std;
int n,m,ans;
int degree[M];
namespace Min_Flow{
    struct abcd{
        int to,f,next;
    }table[1001001];
    int head[M],tot=1;
    int dpt[M];
    void Add(int x,int y,int z)
    {
        table[++tot].to=y;
        table[tot].f=z;
        table[tot].next=head[x];
        head[x]=tot;
    }
    void Link(int x,int y,int z)
    {
        Add(x,y,z);
        Add(y,x,0);
    }
    void Restore()
    {
        int i;
        for(i=head[S];i;i=table[i].next)
            table[i].f=table[i^1].f=0;
        for(i=head[T];i;i=table[i].next)
            table[i].f=table[i^1].f=0;
        for(i=head[TT];i;i=table[i].next)
            if(table[i].to==SS)
            {
                ans+=table[i^1].f;
                table[i].f=table[i^1].f=0;
                break;
            }
        Link(S,TT,INF);
        Link(SS,T,INF);
    }
    bool BFS()
    {
        static int q[M];
        int i,r=0,h=0;
        memset(dpt,-1,sizeof dpt);
        dpt[S]=1;q[++r]=S;
        while(r!=h)
        {
            int x=q[++h];
            for(i=head[x];i;i=table[i].next)
                if(table[i].f&&!~dpt[table[i].to])
                {
                    dpt[table[i].to]=dpt[x]+1;
                    q[++r]=table[i].to;
                    if(table[i].to==T)
                        return true;
                }
        }
        return false;
    }
    int Dinic(int x,int flow)
    {
        int i,left=flow;
        if(x==T) return flow;
        for(i=head[x];i&&left;i=table[i].next)
            if(table[i].f&&dpt[table[i].to]==dpt[x]+1)
            {
                int temp=Dinic(table[i].to,min(left,table[i].f));
                left-=temp;
                table[i].f-=temp;
                table[i^1].f+=temp;
            }
        if(left) dpt[x]=-1;
        return flow-left;
    }
}
int main()
{
    using namespace Min_Flow;
    int i,x,y;
    cin>>n;
    for(x=1;x<=n;x++)
    {
        scanf("%d",&m);
        for(i=1;i<=m;i++)
        {
            scanf("%d",&y);
            degree[x]--;
            degree[y]++;
            Link(x,y,INF);
        }
    }
    for(i=1;i<=n;i++)
    {
        if(degree[i]>0)
            Link(S,i,degree[i]);
        if(degree[i]<0)
            Link(i,T,-degree[i]);
        Link(SS,i,INF);
        Link(i,TT,INF);
    }
    Link(TT,SS,INF);
    while( BFS() )
        Dinic(S,INF);
    Restore();
    while( BFS() )
        ans-=Dinic(S,INF);
    cout<<ans<<endl;
    return 0;
}