最大流最小费用流模板

struct node
{
    int v,f,cos,ne;
}edge[N*N*2];

int head[N],pre[N],dist[N];//head[]为每个变得下标，pre[]用来记录前驱，dist[]最短路时的距离数组
bool spaf_vis[N];//最短路的标记数组
int s,t,e;

void add_insert(int a,int b,int c,int d)
{
    edge[e].v=b;
    edge[e].f=c;
    edge[e].cos=d;
    edge[e].ne=head[a];
    head[a]=e++;
}

void add(int a,int b,int c,int d)
{
    add_insert(a,b,c,d);
    add_insert(b,a,0,-d);
}

int spaf()//寻找花费最少的路径
{
    //跑一遍SPFA 找s——t的最少花销路径 且该路径上每一条边不能满流
    //若存在 说明可以继续增广，反之不能
    memset(spaf_vis,0,sizeof(spaf_vis));
    memset(dist,inf,sizeof(dist));
    memset(pre,-1,sizeof(pre));
    queue<int>que;
    spaf_vis[s]=1;
    dist[s]=0;
    que.push(s);
    while(!que.empty())
    {
        int u=que.front();
        que.pop();
        spaf_vis[u]=0;
        for(int i=head[u];i!=-1;i=edge[i].ne)
        {
            int v=edge[i].v,f=edge[i].f,c=edge[i].cos;
            if(dist[v]>dist[u]+c&&f)
            {
                dist[v]=dist[u]+c;
                pre[v]=i;//记录前驱的下标
                if(!spaf_vis[v])
                {
                    spaf_vis[v]=1;
                    que.push(v);
                }
            }
        }
    }
    return pre[t]!=-1;
}

void MCMF()
{
    int flow=0,cost=0;//总容量和总花费
    while(spaf())//寻找花销最小的路径
    {
        int mini=inf;
        //通过反向弧 在源点到汇点的最少花费路径 找最小增广流
        for(int i=pre[t];i!=-1;i=pre[edge[i^1].v])
            mini=min(mini,edge[i].f);
        for(int i=pre[t];i!=-1;i=pre[edge[i^1].v])
        {
            edge[i].f-=mini;
            edge[i^1].f+=mini;
            cost+=edge[i].cos*mini;
        }
        flow+=mini;
    }
    return cost;
}