最小费用最大流

算法介绍

学完最大流后，又看了看费用流，费用流与最大流相比就是多了一个每条边上的费用，就是走着条边的花费。

好比之前最大流中，从水厂往家里送水，每条管道都有一个容量，而现在又加了一个你每流过一条管道，还需要交一定的钱，总不能白让你送水吧。这就是费用流

每一个网络流图中，最大流只有一个，是唯一的。但达到最大流的路径可能有多个，而其中达到最大流中花的费用最少的那个路径就是最小费用最大流。

算法步骤

那么这个最小费用最大流怎么求呢？

这里采用一种贪心的思想。

1、每次找到一条起源点到汇点花费最少(mincost)的路径。（可以把花费看成“路的长度”，即求最短路）

2、求出这条路径上能流过的最大流量f，这时最大流量maxflow+=f,最小费用Mincost+=f*mincost,这条路径上的每条正向边还要相应的减去f，反向边相应的加上f。

3、重复上述过程直到没有一条可以从源点到汇点的路，即求出最小费用和最大流。

下面附上模板，

由于图中负边的存在，使用spfa找最短路

#include<bits/stdc++.h>
#define exp 1e-8
#define mian main
#define pii pair<int,int>
#define pll pair<ll,ll>
#define ll long long
#define pb push_back
#define PI  acos(-1.0)
#define inf 0x3f3f3f3f
#define w(x) while(x--)
#define int_max 2147483647
#define lowbit(x) (x)&(-x)
#define gcd(a,b) __gcd(a,b)
#define pq(x)  priority_queue<x>
#define ull unsigned long long
#define sc(x) scanf("%d",&x)
#define scl(x) scanf("%lld",&x)
#define pl(a,n) next_permutation(a,a+n)
#define ios ios::sync_with_stdio(false)
#define met(a,x) memset((a),(x),sizeof((a)))
using namespace std;
const int N=1e5+10;
int n,m,tot,s,t,mincost,maxflow;
int head[N],dis[N],pre[N],path[N],vis[N];          //dis数组为求出的到达一点的最小费用
struct node
{
    int v;
    int w;
    int next;
    int cost;
    node()
    {
        v=0;
        w=0;
        next=-1;
        cost=0;
    }
}e[N];
void add(int u,int y,int z,int co)
{
    e[++tot].v=y;
    e[tot].w=z;
    e[tot].next=head[u];
    e[tot].cost=co;
    head[u]=tot;
}
bool spfa()
{
    queue<int>q;
    met(dis,inf);
    met(pre,0);
    met(path,0);
    met(vis,false);
    vis[s]=true;
    dis[s]=0;
    while(!q.empty())
        q.pop();
    q.push(s);
    while(!q.empty()){
        int u=q.front();
        q.pop();
        vis[u]=false;
        for(int i=head[u];i!=-1;i=e[i].next){
            int v=e[i].v;
            if(dis[v]>e[i].cost+dis[u]&&e[i].w>0){
                dis[v]=e[i].cost+dis[u];
                pre[v]=u;         //前一个点
                path[v]=i;     //前一个边
            if(!vis[v]){
                vis[v]=true;
                q.push(v);
            }
          }
        }
    }
    if(dis[t]==inf)
        return false;
    return true;
}
void minf()
{
     maxflow=0;
     mincost=0;
    while(spfa()){
        int f=inf;
        for(int i=t;i!=s;i=pre[i]){
            if(e[path[i]].w<f)
                f=e[path[i]].w;
        }
        mincost+=f*dis[t];
        maxflow+=f;
        for(int i=t;i!=s;i=pre[i]){
            e[path[i]].w-=f;          //正向边减少容量
            e[path[i]^1].w+=f;         //反向边增加流量
        }
    }
}
void init()
{
    tot=-1;
    met(head,-1);
}
int main()
{
    while(~scanf("%d%d%d%d",&n,&m,&s,&t)){
            int x,y,z,f;
            init();
        for(int i=1;i<=m;i++){
            scanf("%d%d%d%d",&x,&y,&z,&f);
            add(x,y,z,f);
            add(y,x,0,-f);             //反向边的花费为负的，因为回流费用减少
        }
        minf();
        printf("%d %d\n",maxflow,mincost);
    }
}