图论专题-网络流-学习笔记：EK 求解费用流

目录

• 1. 前言
• 2. 详解
• 3. 总结

1. 前言

费用流，全称最小费用最大流，是网络流的一个分支。

最小费用最大流的问题描述如下：

给出一张网络 $G=<V,E>$，每条边有两个权值：$f,v$。

$f$ 表示这条边的最大流量，$v$ 表示单位花费，也就是说从这条边每流过一单位流量就要增加 $v$ 的花费。

现在要求这张网络的最小费用最大流，也就是在保证总流量最大的情况下总费用最小。

在往下看之前，您需要对以下知识有所了解：

1. SPFA 最短路径算法。传送门：P3371 【模板】单源最短路径（弱化版） 题解
2. EK 求解最大流。传送门：图论专题-网络流-学习笔记：EK 求解最大流

2. 详解

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

首先回顾一下 EK 求解最大流的思路：

采用 BFS 来不断寻找增广路，每一次找到一条之后就更新这一条边上的流量，同时建立反向边进行反悔。

但是现在加了一条限制：总流量最大之外总费用最小。

啊这？这要怎么做啊？

假设现在从 $s$ 到 $t$ 有两条路径。

我们分类讨论一下：

• 如果这两条路径能够流过的流量相同，那么我们需要求出这两条费用较小的一条，这个可以用最短路来寻找增广路。
• 如果这两条路径能够流过的流量不同：
  • 如果流量较大那条边费用比较小，那么最短路寻找增广路的时候一定会找到这条路径，于是保证流量最大且费用最小。
  • 但是如果流量较大那条边费用比较大呢？那么第一次跑最短路的时候找到的是另外那条边，正确性似乎没了保证。
  • 可是，流量较大那条边因为第一次没有被遍历到，因此它是图中的一条 增广路。而根据 EK 求解最大流的步骤，只要有增广路就会继续推流，而且没有流量的边是会被忽略掉的。这样，即使第一次找的是流量花费较小的边，流量花费较大的边在后面也会被找到。

综上，只需要使用最短路来代替 EK 中的 BFS 就可以找到最小费用最大流了。

但是怎么求最短路呢？

某同学：笔者是不是没学过图论啊，这不是裸的 dijkstra 就好了吗？

如果您的选择是 dijkstra，那么您就需要先对图进行一定的处理。

为什么？看一下下面加粗的部分：

反向边！

在 EK 中，反向边是拿来反悔用的，也就是给出一次回退的机会。

而如果要反悔，流回去的流量是要减少一定量的花费的。

于是反向边的花费是正向边花费的相反数。

于是这张图有了负权边。

于是 dijkstra 死了

某同学：啊不是，话说 SPFA 不是很容易卡的吗？dijkstra 没用了？

实际上如果对网络进行一些奇怪的处理之后是可以使用 dijkstra，但是一般网络流的题目主要考查建模能力，用 SPFA 也不会太差。

当然真的被卡了笔者也没办法，还是老老实实写 dijkstra 吧。

代码：

/*
========= Plozia =========
	Author:Plozia
	Problem:P3381 【模板】最小费用最大流——EK 写法
	Date:2021/3/23
========= Plozia =========
*/

#include <bits/stdc++.h>
using std::queue;

typedef long long LL;
const int MAXN = 5e3 + 10, MAXM = 5e4 + 10, INF = 0x7f7f7f7f;
int n, m, s, t, dis[MAXN], Flow[MAXN], Head[MAXN], cnt_Edge = 1, pre[MAXN], ans_flow, ans_spend;
struct EDGE {int to, w, c, Next;} Edge[MAXM << 1];
bool book[MAXN];

int read()
{
	int sum = 0, fh = 1; char ch = getchar();
	for (; ch < '0' || ch > '9'; ch = getchar()) fh = (ch == '-') << 1;
	for (; ch >= '0' && ch <= '9'; ch = getchar()) sum = (sum << 3) + (sum << 1) + (ch ^ 48);
	return (fh == 1) ? sum : -sum;
}
void add_Edge(int u, int v, int w, int c) {Edge[++cnt_Edge] = (EDGE){v, w, c, Head[u]}; Head[u] = cnt_Edge;}
int Min(int fir, int sec) {return (fir < sec) ? fir : sec;}

bool SPFA()
{
	queue <int> q; q.push(s);
	memset(dis, 0x7f, sizeof(dis));
	memset(Flow, 0x7f, sizeof(Flow));
	memset(pre, 0, sizeof(pre));
	memset(book, 0, sizeof(book));
	dis[s] = 0; book[s] = 1;
	while (!q.empty())
	{
		int x = q.front(); q.pop(); book[x] = 0;
		for (int i = Head[x]; i; i = Edge[i].Next)
		{
			int u = Edge[i].to;
			if (Edge[i].w > 0 && dis[u] > dis[x] + Edge[i].c)
			{
				dis[u] = dis[x] + Edge[i].c;
				Flow[u] = Min(Edge[i].w, Flow[x]);
				pre[u] = i;
				if (!book[u]) {book[u] = 1; q.push(u);}
			}
		}
	}
	return dis[t] != INF;
}

void EK()
{
	while (SPFA())
	{
		int x = t;
		for (; x != s; )
		{
			int k = pre[x];
			Edge[k].w -= Flow[t];
			Edge[k ^ 1].w += Flow[t];
			x = Edge[k ^ 1].to;
		}
		ans_flow += Flow[t];
		ans_spend += Flow[t] * dis[t];
	}
}

int main()
{
	n = read(), m = read(), s = read(), t = read();
	for (int i = 1; i <= m; ++i)
	{
		int u = read(), v = read(), w = read(), c = read();
		add_Edge(u, v, w, c); add_Edge(v, u, 0, -c);
	}
	EK(); printf("%d %d\n", ans_flow, ans_spend);
	return 0;
}

3. 总结

EK 求解费用流就是用 SPFA 来代替 BFS 即可。

但是根据某法律：卡 EK 合法，卡 dinic 不合法！（笔者是真的不知道这个法律哪来的），因此还需要掌握 dinic 求解费用流。

传送门：图论专题-网络流-学习笔记：dinic 求解费用流