最小费用最大流

模板题.

最大流模板题——传送门.

听名字就可以看出，要在满足最大流的同时找到达成最大流的最小费用。

我们用每条边单位流量的花费作为边权，假如一条合法路径上每条边的花费分别为 cost[1],cost[2],…c[k] ， 并且这条边上的最小流量为flow，那么这条路径上的花费为 ： c[1] * flow + c[2] * flow + … + c[k] * flow = （c1+ c2 + c3 + … + ck）* flow = dis [ci] * flow
所以dis[ci]最小就是相当于最短路，这里用spfa算法实现。

思想

采用贪心的思想，每次找到一条从源点到达汇点的路径，增加流量，且该条路径满足使得增加的流量的花费最小，直到无法找到一条从源点到达汇点的路径，算法结束。
由于最大流量有限，每执行一次循环流量都会增加，因此该算法肯定会结束，且同时流量也必定会达到网络的最大流量；同时由于每次都是增加的最小的花费，即当前的最小花费是所有到达当前流量flow时的花费最小值，因此最后的总花费最小。

代码步骤

1、找到一条从s到t的花费最少的路径称为增广路，花费 = 径路花费之和
2、找到该路径上边的剩余容量的最小值flow，max_flow+=flow，同时最小费用min_cost+=flow * cost[t]
3、更新路径流量，正向边流量减，反向边流量加，。
4、重复步骤1~3，知道找不到增广路

代码

#include <bits/stdc++.h>
#define inf 0x3f3f3f3f 
#define ll long long
#define T int t;scanf("%d", &t);while(t--)
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 5e5 + 5;
int head[5005];
int vis[5005]; //标记是否在队列
int pre[5005];	//存爸爸	用于遍历路径更新边的剩余容量。
int cost[5005];	//花费最短路
int flow[5005];	//最大流的最小流量
int last[100005]; //存边的编号
ll max_flow = 0; //最大流
ll min_cost = 0; //最小费用
int n,m,s,t;
struct edge{
	int flow; //当前边的流量
	int to;
	int nxt;
	int cost;
}e[100005];
int cnt = 0;
int add(int u,int v, int flow, int cost){
	e[cnt].to = v;
	e[cnt].cost = cost;
	e[cnt].flow = flow;
	e[cnt].nxt = head[u];
	head[u] = cnt ++;	
}
int spfa(){
	for(int i = 1; i <= n; i ++) {	
		cost[i] = inf;
		vis[i] = 0;
		flow[i] = inf;
	}
	queue<int> q;
	q.push(s);
	vis[s] = 1;
	pre[t] = -1;
	cost[s] = 0;
	while(!q.empty()){
		int u = q.front();
		q.pop();
		vis[u] = 0;	//出队列标记
		for(int i = head[u]; i != -1; i = e[i].nxt){
			int v = e[i].to;
			//剩余容量>0 
			if(e[i].flow > 0 && cost[v] > cost[u] + e[i].cost){
				cost[v] = cost[u] + e[i].cost;
				pre[v] = u;
				last[v] = i;	//存下边的编号，用于更新边的剩余容量
				flow[v] = min(flow[u],e[i].flow);
				if(vis[v] == 0){
					vis[v] = 1;	//入队列标记
					q.push(v);
				}
			}
		}
	}
	return pre[t] != -1; 
}
int main(){
	memset(head,-1,sizeof(head));
	scanf("%d %d", &n, &m);
	s = 1;
	t = n;
	while(m--){
		int u,v,cost,flow;
		scanf("%d %d %d %d", &u, &v, &flow, &cost);
		add(u,v,flow,cost);
		add(v,u,0,-cost);		//反向边！！！
	}
	while(spfa()){  //能找到增广路就更新
		int now = t;
		max_flow += flow[t];		//更新最大流
		min_cost += flow[t]*cost[t];	//更新费用
		while(now!=s){
			e[last[now]].flow -= flow[t]; 	//更新边的剩余容量
			e[last[now] ^ 1].flow += flow[t]; //反向边
			now = pre[now]; //上个点
		}
	}
	printf("%lld %lld\n", max_flow, min_cost);
	
    return 0;
}