最小费用最大流模版

struct edge
{
    int num,len,C;
    edge *next,*rev;
}*S[nnMax],pool[MMax];

int d[nnMax];
edge *P[nnMax];
bool inq[nnMax];
queue<int> Q;

void build_edge(int x,int y,int z,int C)
{
    edge *p=&pool[L++],*q=&pool[L++];
    p->num=y;p->len=z;p->C=C;p->next=S[x];S[x]=p;p->rev=q;
    q->num=x;q->len=0;q->C=-C;q->next=S[y];S[y]=q;q->rev=p;
}

/*****************************************************************/

int Dinic()

{
    int ans=0;
    while(1)
    {
        for(int i=0;i<=nn;i++)
        {
            d[i]=(~0u>>1);
            inq[i]=0;
            P[i]=NULL;
        }
        while(!Q.empty()) Q.pop();
        d[0]=0;inq[0]=1;Q.push(0);
        while(!Q.empty())
        {
            int tmp=Q.front();Q.pop(); inq[tmp]=0;
            for(edge *p=S[tmp];p;p=p->next)
            {
                if(p->len && d[p->num]>d[tmp]+p->C)
                {
                    d[p->num]=d[tmp]+p->C;
                    P[p->num]=p->rev;
                    if(!inq[p->num])
                    {
                        inq[p->num]=1;
                        Q.push(p->num);
                    }
                }
            }
        }
        if(d[nn]==(~0u>>1)) break;
        int flow=(~0u>>1),tmp=nn;
        while(P[tmp]!=NULL)
        {
            flow=min(flow,P[tmp]->rev->len);
            tmp=P[tmp]->num;
        }
        tmp=nn;
        while(P[tmp]!=NULL)
        {
            P[tmp]->rev->len-=flow;
            P[tmp]->len+=flow;
            ans+=flow*(P[tmp]->rev->C);
            tmp=P[tmp]->num;
        }
    }
    return ans;
}