最小费用最大流模板

算法引入：
任何容量网络的最大流流量是唯一且确定的，但是它的最大流f并不是唯一的;
既然最大流f不唯一，因此，如果每条弧上不仅有容量限制，还有费用r;
即每条弧上有一个单位费用的参数，那么在保证最大流的前提下;
还存在一个选择费用最小的最大流问题，即为最小费用最大流问题;

算法思想：
寻找最大流的方法是从某个可行流出发，找到关于这个流的一条增广路P;
沿着P调整f，对新的可行流又试图寻找关于它的增广路，循环直至不存在增广路为止;
要求最小费用最大流：
如果f是流量为f1的可行流中费用最小者，而p是关于f的所有增广路中费用最小的增广路;
那么沿着p去调整f，得到可行流_f，就是流量为f1的所有可行流中的费用最小者;
这样当f是最大流时，它也就是所要求的最小费用最大流了;

const int N=1100,INF=0x3f3f3f3f;
const int M=N*N;
int pre[N],d[N],p[N],ans;
int cnt,head[N];
int q[M],l,r;
struct edge
{
    int u,v,w,c,next;
}e[M];
void init()
{
    memset(head,-1,sizeof(head));
    ans=cnt=0;
}
void add(int u,int v,int w,int c)
{
    e[cnt].u=u,e[cnt].v=v,e[cnt].w=w,e[cnt].c=c;
    e[cnt].next=head[u],head[u]=cnt++;
    e[cnt].u=v,e[cnt].v=u,e[cnt].w=-w,e[cnt].c=0;
    e[cnt].next=head[v],head[v]=cnt++;
}
void updata(int s,int t)
{
    int i,f=INF;
    for(i=t;i!=s;i=e[pre[i]].u)
        f=min(f,e[pre[i]].c);
    for(i=t;i!=s;i=e[pre[i]].u)
    {
       e[pre[i]].c-=f;
       e[pre[i]^1].c+=f;
       ans+=f*e[pre[i]].w;
    }
}
int spfa(int s,int t)
{
    int i,u,v,w;
    memset(p,0,sizeof(p));
    memset(pre,-1,sizeof(pre));
    memset(d,0x3f,sizeof(d));
    l=r=0;
    q[++r]=s,p[s]=1,d[s]=0;
    while(l<r)
    {
        p[u=q[++l]]=0;
        for(i=head[u];i!=-1;i=e[i].next)
        {
            v=e[i].v,w=e[i].w;
            if(e[i].c&&d[v]>d[u]+w)
            {
                d[v]=d[u]+w;
                pre[v]=i;
                if(!p[v])
                {
                    p[v]=1;
                    q[++r]=v;
                }
            }
        }
    }
    if(pre[t]==-1)
        return 0;
    return 1;
}
void MiCMaF(int s,int t)
{
    ans=0;
    while(spfa(s,t))
        updata(s,t);
}

 例题：POJ 2135

参考文章：http://blog.csdn.net/jarily/article/details/8613208