网络流总结

1.最大流
有一个有向图，u到v的有向边表示水可以从u流向v
边上有容量，表示水最多流过去的量
有一个源点一个汇点，从源点这倒水，水通过流网络流向汇点，问这个流网络最多可以承受多少倒进去的水
这个问题就是最大流
在解决实际问题时主要还是建模比较考思维
有几个现成的例子比如二分图跑最大流，或者由最大流可以解决最小割而引出的最大密度子图这些
还有一个分支就是平面图最大流（狼抓兔子）考到了平面图的对偶图
这是暑假讲的了
贴一个模板

//总点数n+m+2,编号从0开始,源点0,汇点n+m+1struct node{    int v,w,next,op;}edge[360020];int head[360020],d[60000],vd[60000],n,m,flow,cnt;void addedge(int u,int v,int w){    edge[++cnt].v=v;    edge[cnt].w=w;    edge[cnt].op=cnt+1;    edge[cnt].next=head[u];    head[u]=cnt;    edge[++cnt].v=u;    edge[cnt].w=0;    edge[cnt].op=cnt-1;    edge[cnt].next=head[v];    head[v]=cnt;}int aug(int u,int augco){    if(u==n+m+1)return augco;    int augc=augco,mind=n+m+1;    for(int i=head[u];i;i=edge[i].next)    {        int v=edge[i].v;        if(d[u]==d[v]+1&&edge[i].w>0)        {            int delta=min(augc,edge[i].w);            delta=aug(v,delta);            edge[i].w-=delta;            edge[edge[i].op].w+=delta;            augc-=delta;            if(d[0]>=n+m+2)return augco-augc;            if(augc==0)break;        }        if(edge[i].w>0)mind=min(mind,d[v]);    }    if(augco==augc)    {        vd[d[u]]--;        if(vd[d[u]]==0)d[0]=n+m+2;        else        {            d[u]=mind+1;            vd[d[u]]++;        }    }    return augco-augc;}void sap(){    vd[0]=n+m+2;    while(d[0]<n+m+2)flow+=aug(0,999999999);}

2.费用流
还是上面那个问题，不过现在流网络不是你家开的，每用一条边流水，都要交钱，每单位的水对于不同的边交不同的钱，还是想流过去的水最多，而且要交的钱最少
这是最小费用最大流
建模的时候有个技巧就是拆点，把一个点拆成两个中间连一条边表示选这个东西的费用
写法好像挺多的样子。。学习了一下SPFA和zkw的费用流
实测zkw很多时候要快一些
贴两个写法的模板
POJ 2195

#include<iostream>#include<cstdio>#include<cstring>#include<queue>#include<vector>#define pii pair<int,int>using namespace std;vector<pii>H,M;struct node{    int v,next,cost,cap;}edge[100000];int n,m,cnt,src,des,ans,head[300],dis[300];bool vis[300],inq[300];char c;int abs(int x){    return x<0?-x:x;}int getd(pii x,pii y){    return abs(x.first-y.first)+abs(x.second-y.second);}void addedge(int u,int v,int cost,int cap){    edge[cnt].v=v;    edge[cnt].cost=cost;    edge[cnt].cap=cap;    edge[cnt].next=head[u];    head[u]=cnt++;}bool spfa(){    queue<int>q;    q.push(des);    memset(dis,0x3f,sizeof dis);    inq[des]=1;    dis[des]=0;    while(!q.empty())    {        int u=q.front();        q.pop();        inq[u]=0;        for(int i=head[u];~i;i=edge[i].next)        {            int v=edge[i].v;            if(edge[i^1].cap>0&&dis[v]>dis[u]+edge[i^1].cost)            {                dis[v]=dis[u]+edge[i^1].cost;                if(!inq[v])q.push(v),inq[v]=1;            }        }    }    if(dis[src]==0x3f3f3f3f)return 0;    return 1;}int aug(int u,int augco){    if(u==des)    {        ans+=dis[src]*augco;        return augco;    }    int augc=augco,delta;    for(int i=head[u];~i;i=edge[i].next)        if(!vis[edge[i].v]&&edge[i].cap>0&&dis[edge[i].v]==dis[u]-edge[i].cost)        {            vis[edge[i].v]=1;            delta=aug(edge[i].v,min(augc,edge[i].cap));            augc-=delta;            edge[i].cap-=delta;            edge[i^1].cap+=delta;        }    return augco-augc;}int main(){    while(scanf("%d%d",&n,&m)&&n&&m)    {        H.clear();        M.clear();        memset(inq,0,sizeof inq);        memset(head,-1,sizeof head);        cnt=ans=0;        for(int i=1;i<=n;++i)        {            c=getchar();            for(int j=1;j<=m;++j)            {                c=getchar();                if(c=='H')H.push_back(pii(i,j));                else if(c=='m')M.push_back(pii(i,j));            }        }        int hsz=H.size(),msz=M.size();        for(int i=0;i<msz;++i)        {            addedge(1,i+2,0,1);            addedge(i+2,1,0,0);            for(int j=msz;j<hsz+msz;++j)            {                int d=getd(M[i],H[j-msz]);                addedge(i+2,j+2,d,1);                addedge(j+2,i+2,-d,0);            }        }        for(int i=msz;i<hsz+msz;++i)        {            addedge(i+2,hsz+msz+2,0,1);            addedge(hsz+msz+2,i+2,0,0);        }        src=1,des=hsz+msz+2;        while(spfa())        {            memset(vis,0,sizeof vis);            vis[src]=1;            aug(src,999999999);        }        printf("%d\n",ans);    }}

#include<iostream>#include<cstdio>#include<cstring>#include<queue>#include<vector>#define pii pair<int,int>using namespace std;vector<pii>H,M;struct node{    int v,next,cost,cap;}edge[100000];int n,m,cnt,src,des,ans,head[300],dis[300];bool vis[300];char c;int abs(int x){    return x<0?-x:x;}int getd(pii x,pii y){    return abs(x.first-y.first)+abs(x.second-y.second);}void addedge(int u,int v,int cost,int cap){    edge[cnt].v=v;    edge[cnt].cost=cost;    edge[cnt].cap=cap;    edge[cnt].next=head[u];    head[u]=cnt++;}bool label(){    int mi=999999999;    for(int i=src;i<=des;++i)    {        if(vis[i])        {            for(int j=head[i];~j;j=edge[j].next)                if(!vis[edge[j].v]&&edge[j].cap>0)                    mi=min(mi,edge[j].cost+dis[edge[j].v]-dis[i]);        }    }    if(mi==999999999)return 0;    for(int i=src;i<=des;++i)        if(vis[i])dis[i]+=mi;    return 1;}int aug(int u,int augco){    if(u==des)    {        ans+=dis[src]*augco;        return augco;    }    int augc=augco,delta;    vis[u]=1;    for(int i=head[u];~i&&augc>0;i=edge[i].next)        if(edge[i].cap>0&&!vis[edge[i].v]&&edge[i].cost+dis[edge[i].v]==dis[u])        {            delta=aug(edge[i].v,min(edge[i].cap,augc));            augc-=delta;            edge[i].cap-=delta;            edge[i^1].cap+=delta;        }    return augco-augc;}int main(){    while(scanf("%d%d",&n,&m)&&n&&m)    {        H.clear();        M.clear();        memset(dis,0,sizeof dis);        memset(vis,0,sizeof vis);        memset(head,-1,sizeof head);        cnt=ans=0;        for(int i=1;i<=n;++i)        {            c=getchar();            for(int j=1;j<=m;++j)            {                c=getchar();                if(c=='H')H.push_back(pii(i,j));                else if(c=='m')M.push_back(pii(i,j));            }        }        int hsz=H.size(),msz=M.size();        for(int i=0;i<msz;++i)        {            addedge(1,i+2,0,1);            addedge(i+2,1,0,0);            for(int j=msz;j<hsz+msz;++j)            {                int d=getd(M[i],H[j-msz]);                addedge(i+2,j+2,d,1);                addedge(j+2,i+2,-d,0);            }        }        for(int i=msz;i<hsz+msz;++i)        {            addedge(i+2,hsz+msz+2,0,1);            addedge(hsz+msz+2,i+2,0,0);        }        src=1,des=hsz+msz+2;        do        {            do            {                memset(vis,0,sizeof vis);            }while(aug(src,999999999));        }while(label());        printf("%d\n",ans);    }}

然后上面说的是最小费用流
现在假设这个流网络是你家开的，别人来你这灌水，你收别人钱
你想找一个方案，让他灌的水最多并且给你的钱最多
这个是最大费用流
写法一样，费用存进去的时候记得取反
得到答案后记得还原
3.上下界网络流
有三个子问题：
a.无源汇点的可行流
网络流当中没有源点汇点，那么这一定是一个循环流，即水流绕圈流动
问存不存在这样的流
这个麻烦在有上下界，普通网络流只有上界而无下界，所以这驱使我们思考怎么消除下界影响
假设一个点下界流进去a，下界流出去b
如果a大于b，那么说明下界流进去很多，而只满足下界的话流出来不够，需要自由流（就是在上下界之间的流量）来补
如果a小于b，那么说明下界流进去很少，而只满足下界的话流出来就已经超了，需要自由流（就是在上下界之间的流量）来补
所以我们现在考虑的问题就转化成了自由流怎么补满每个点
这就变成了一个普通的最大流问题了。
总结一下，先新建源点汇点，对每个点，统计流入的下界和流出的下界之差，如果流入的小于流出来的，就从源点往这个点连边，容量是差值的相反数
如果流入的大于流出的，就从这个点连一条容量为差值的边到汇点去
对于原图中的点，如果有边相连那么容量是上界-下界
最后跑最大流，如果源点出去的每个边满流那么有可行流
贴一个模板SGU176

#include<iostream>#include<cstdio>#include<cstring>using namespace std;struct node{    int v,next,cap;}edge[100010];int n,m,cnt,flow,src,des,head[210],upl[50010],dwl[50010],io[210],d[210],vd[210];void addedge(int u,int v,int cap){    edge[cnt].v=v;    edge[cnt].cap=cap;    edge[cnt].next=head[u];    head[u]=cnt++;}int aug(int u,int augco){    if(u==n+1)return augco;    int augc=augco,mind=n+1;    for(int i=head[u];~i;i=edge[i].next)    {        int v=edge[i].v;        if(d[u]==d[v]+1&&edge[i].cap>0)        {            int delta=aug(v,min(augc,edge[i].cap));            edge[i].cap-=delta;            augc-=delta;            edge[i^1].cap+=delta;            if(d[0]>=n+2)return augco-augc;            if(augc==0)break;        }        if(edge[i].cap>0)mind=min(mind,d[v]);    }    if(augco==augc)    {        vd[d[u]]--;        if(vd[d[u]]==0)d[0]=n+2;        else        {            d[u]=mind+1;            vd[d[u]]++;        }    }    return augco-augc;}void sap(){    vd[0]=n+2;    while(d[0]<n+2)flow+=aug(0,2147483640);    for(int i=head[src];~i;i=edge[i].next)        if(edge[i].cap)        {            puts("NO");            return;        }    puts("YES");    for(int i=0;i<m;++i)        printf("%d\n",dwl[i]+edge[i*2+1].cap);}int main(){    memset(head,-1,sizeof head);    scanf("%d%d",&n,&m);    src=0,des=n+1;    for(int i=0,u,v;i<m;++i)    {        scanf("%d%d%d%d",&u,&v,&dwl[i],&upl[i]);        addedge(u,v,upl[i]-dwl[i]);        addedge(v,u,0);        io[u]-=dwl[i];        io[v]+=dwl[i];    }    for(int i=1;i<=n;++i)    {        if(io[i]>0)addedge(src,i,io[i]),addedge(i,src,0);        else if(io[i]<0)addedge(i,des,-io[i]),addedge(des,i,0);    }    sap();}

b.有源汇点的最大流
对于这个图，首先要考虑的是有没有可行流。于是想办法把有源汇点的图转化成没有源汇点的图，方法很简单就是从汇点连一条容量为无穷大的边到源点，说白了就是你在源点灌水，汇点的人收到水之后把收到的水搬过来给你，你又往源点里面倒
这样流网络就只有循环流了
于是对这个没有源汇点的图跑一个可行流，建图方法同上
如果可行，那么考虑现在这个图的残留网络，显然边的下界都被满足了，然而自由流只是找了一条可行流出来，不一定最优，于是还可以对自由流跑最大流以求出原图的最大流，方法是删掉刚才新加的源点汇点和汇点到源点的边，注意到现在这个图就是只表示自由流了，对这个图求个最大流，答案就是刚才的可行流+现在的最大流
当然二分也可以，从汇点往源点连一条下界为a，上界无穷大的边，说白了你给在汇点的人说了，收到的水必须多于a才能搬回来，然后对这个图做可行流，看看可行不，通过二分调节a的取值最后得到最大值就是答案
c.有源汇点的最小流
既然有下界那么自然可以求最小流
方法是对原图做可行流，不过这次不加汇点到源点那条边，跑个最大流，然后再加上汇点到源点那条边再跑一次最大流。答案就是第二次跑的最大流。
感性理解是最终解只能是加上边后，求的无源汇可行流，即T->S这边上的流量. 不改成无源汇的直接求的解是未必正确的
然后，因为第一遍做的时候并无这条边，所以S->T的流量在第一遍做的时候都已经尽力往其他边流了. 于是加上T->S这条边后，都是些剩余的流不到其他边的流量. 从而达到尽可能减少T->S这边上的流量的效果，即减小了最终答案.本质是延迟对T->S这条边的增流.
当然二分也可以，从汇点往源点连一条下界为0，上界为a的边.