P3381 【模板】最小费用最大流

题目描述

如题，给出一个网络图，以及其源点和汇点，每条边已知其最大流量和单位流量费用，求出其网络最大流和在最大流情况下的最小费用。

输入输出格式

输入格式：

第一行包含四个正整数N、M、S、T，分别表示点的个数、有向边的个数、源点序号、汇点序号。

接下来M行每行包含四个正整数ui、vi、wi、fi，表示第i条有向边从ui出发，到达vi，边权为wi（即该边最大流量为wi），单位流量的费用为fi。

输出格式：

一行，包含两个整数，依次为最大流量和在最大流量情况下的最小费用。

输入样例1：

4 5 4 3
4 2 30 2
4 3 20 3
2 3 20 1
2 1 30 9
1 3 40 5

输出样例1：

50 280

思路：

　　MCMF算法。最大流流量不变，但从源点到汇点的走法不同，所以路径花费就不同。该算法的思想是在保证最大流量的情况下寻找一条花费最小的增广路。也就是把原来的bfs换成spfa。

解析：

　　dis[]表示该点的花费是多少，pre[]表示该点的前驱是什么，last[]表示连接该点的上一条边是什么(便于回溯更新流量)，flow[]表示流量的大小。其中last[]与pre[]用来在spfa之后更新剩余流量。

代码：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<cstring>

const int MAXN=100008;
const int inf=0x7fffffff;

using namespace std;

static int n,m,s,t,maxflow,mincost;
static int head[MAXN],dis[MAXN],vis[MAXN],flow[MAXN],pre[MAXN],last[MAXN],num_edge=1;

struct Edge{
    int next,to,flow,dis;
}edge[MAXN];

queue < int > q;

long long read()
{
    long long x=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

void addedge(int from,int to,int flow,int dis)
{
    edge[++num_edge].next=head[from];
    edge[num_edge].dis=dis;
    edge[num_edge].flow=flow;
    edge[num_edge].to=to;
    head[from]=num_edge;
}

int spfa(int s,int t)
{
    for(int i=1;i<=n;++i)//初始化 
    {
        dis[i]=inf;
        flow[i]=inf;
    }
//    memset(dis,0x7f,sizeof(dis));//初始化 
//    memset(flow,0x7f,sizeof(flow));//初始化 
    memset(vis,0,sizeof(vis));//初始化 
    dis[s]=0;vis[s]=1;pre[t]=-1;//初始化,把pre[t]设为-1是因为如果跑完一遍spfa之后若没有更新到汇点，说明没有一条增广路径 
    q.push(s);
    while(!q.empty())
    {
        int now=q.front();
        q.pop();
        vis[now]=0;
        for(int i=head[now];i;i=edge[i].next)
        {
            int v=edge[i].to;
            if(edge[i].flow&&dis[v]>dis[now]+edge[i].dis)//若果该边还有剩余流量，并且满足dis的更新条件 
            {
                dis[v]=dis[now]+edge[i].dis;
                pre[v]=now;//更新前驱 
                last[v]=i;//标记编号，便于回溯 
                flow[v]=min(flow[now],edge[i].flow);//更新能更新的最小流量 
                if(!vis[v])
                {
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
    }
    return pre[t]!=-1;//若pre[t]==-1说明没有增广路径了 
}

void MCMF()
{
    while(spfa(s,t))//如果还能找到一条增广路径 
    {
        int now=t;//定义now是为了在下一个while中便于回溯 
        maxflow+=flow[t];//计算该条增广路径的流量 
        mincost+=flow[t]*dis[t];//计算该条增广路径的花费 
        while(now!=s)//如果没有回溯到源点 
        {
            edge[last[now]].flow-=flow[t];//正向边减去流量 
            edge[last[now]^1].flow+=flow[t];//反向边增加流量 
            now=pre[now];//把now更新为它的前驱 
        }
    }
}

int main()
{
    n=read();m=read();s=read();t=read();
    for(int i=1;i<=m;++i)
    {
        static int x,y,z,f;
        x=read();y=read();z=read();f=read();
        addedge(x,y,z,f);//建边 
        addedge(y,x,0,-f);//建立反向边 
    }
    MCMF();
    printf("%d %d",maxflow,mincost);
    return 0;
}