最小費用最大流模板

算法引入：
任何容量網絡的最大流流量是唯一且確定的，但是它的最大流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