2171. EK求最大流（最大流算法）

Landing_on_Mars

已于 2024-03-02 21:09:11 修改

阅读量429

点赞数 9

分类专栏： # 网络流问题文章标签：算法数据结构最大流

于 2023-11-24 15:16:17 首次发布

本文链接：https://blog.csdn.net/Landing_on_Mars/article/details/134599590

版权

网络流问题专栏收录该内容

34 篇文章 0 订阅

订阅专栏

给定一个包含 n 个点 m 条边的有向图，并给定每条边的容量，边的容量非负。

图中可能存在重边和自环。求从点 S 到点 T 的最大流。

输入格式

第一行包含四个整数 n,m,S,T

接下来 m 行，每行三个整数 u,v,c，表示从点 u 到点 v 存在一条有向边，容量为 c。

点的编号从 1 到 n。

输出格式

输出点 S 到点 T 的最大流。

如果从点 S 无法到达点 T 则输出 0。

数据范围

2≤n≤1000
1≤m≤10000
0≤c≤10000
S≠T

输入样例：

输出样例：

解析：

流网络（有向图，可以有环）G=(V,E)：

源点:s（起点），汇点:t（终点），流量:C(u,v)。

可行流 f:

1.容量限制（每条边的流量不超过其容量）:0<=f(u,v)<=C(u,v)

2.流量守恒：每条边流进多少就流出多少

|f|=sum(s,v):f(s,v)-sum(v,s):f(v,s)

最大流：最大可行流

残留网络Gf： 这某条可行流而言

Vf=V，Ef=E且包含E中的反向边，初始的残留网络（residual graph）的每条边的容量等于原图边的容量

定理：

f+f'（残留网络的可行流的流量方案）也是 G 的一个可行流，既有 |f+f'|=|f|+|f'|。

增广路径：

在残留网络里，沿着容量大于零的边的简单路径，如果能够走到终点的话，这条简单路径就是增广路。

割：
将点集V分成S和T两部分，其中S和T不重不漏,且s属于S，t属于T

最小割:

最小割是网络流中的一个重要概念，它指的是将网络流图中的顶点分为两个不相交的子集合，使得从源点到汇点的所有路径中，经过的边的容量之和最小。

割的容量：

割的容量是指跨越割的边的容量之和（考虑反向边）

c(S,T)=∑u∈S∑v∈T c(u,v)

割的流量：

割的流量是从源点到汇点的所有路径中，跨越割的边的流量之和。（不考虑反向边）

f(S,T)=∑u∈S∑v∈T f(u,v)

性质:

f(S,T)<=c(S,T)

f(S,T)=|f|

|f|<=c(S,T)

最大流 <= 最小割的流量

最大流最小割定理（三个等价的结论）：

1.可行流f是最大流

2.可行流f的残留网络中不存在增广路

3.存在某个割 [S,T] , |f|=c(S,T)

———————————————————————————————————————————

最小割应用：

最大权独立集 = 总权值 − 最小权点覆盖集

最小割 = 最小权点覆盖

最大权闭合子图 = 正权点的权值和 − 最小割

———————————————————————————————————————————
Ford-Fulkerson Algorithm 寻找网络最大流：
最外情况下循环次数等最大流的大小；
最坏情况下的时间复杂度 O(fm);
f:表示最大流
m:表示边（寻找简单路径花费的时间）

Ford-Fulkerson Algorithm 寻找网络最大流：（找增广路，更新can'liu'wang'lu）
1.创建一个residual graph,初始的residual graph的每条边的容量等于原图边的容量
2.做循环：
   a.在residual graph中寻找从起点到终点的简单路径
   b.寻找这条路径上的最小权重x，即为该路径的容量
   c.更新residual graph（路径上的所有权值都减去该路径的流量，即为b中的x）
   d.添加一条反向路径（路径上的权重都等于x）

EK算法与Ford-Fulkerson几乎完全一样，唯一的区别是EK算法寻找简单路径的时候要用最短路算法，且将所有权值当作1
时间复杂度是 O(n*m^2),m是边数，n是点数

使用EK算法的技巧：
1.我们使用链式前向星建的图，这里我们一开始就建好每条边的反向边，且每条边的反向边与正向边相邻，如 i=0 存正向边，那么 i=1 存反向边，这样求一条边的反向边只需要按为取反即可
2.求最短路时，因为每条边的权值为 1 ，所以我们直接使用 bfs 求最短路即可
3.因为我们每次求完一条简单路径后需要将每单路径上的所有边都减去流量，反边加上流量，所以我们需要使用 pre 数组来存储前驱。这里 pre 存储边而非节点。

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>

using namespace std;
typedef long long LL;
const int N = 1e3 + 5, M = 2e4 + 5, inf = 0x3f3f3f3f;
int n, m, S, T;
int h[N], e[M], w[M], ne[M], idx;
int q[N], pre[N], d[N];
bool v[N];

void add(int a, int b, int c) {
	e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
	e[idx] = a, w[idx] = 0, ne[idx] = h[b], h[b] = idx++;
}

int bfs() {
	int hh = 0, tt = 0;
	memset(v, 0, sizeof v);
	q[0] = S, v[S] = 1, d[S] = inf;
	while (hh <= tt) {
		int t = q[hh++];
		for (int i = h[t]; i != -1; i = ne[i]) {
			int j = e[i];
			if (!v[j] && w[i]) {
				v[j] = 1;
				d[j] = min(d[t], w[i]);
				pre[j] = i;
				if (j == T)return 1;
				q[++tt] = j;
			}
		}
	}
	return 0;
}

int EK() {
	int ret = 0;
	while (bfs()) {
		ret += d[T];
		for (int i = T; i != S; i = e[pre[i] ^ 1]) {
			w[pre[i]] -= d[T], w[pre[i] ^ 1] += d[T];
		}
	}
	return ret;
}

int main() {
	memset(h, -1, sizeof h);
	scanf("%d%d%d%d", &n, &m, &S, &T);
	for (int i = 1,a,b,c; i <= m; i++) {
		scanf("%d%d%d", &a, &b, &c);
		add(a, b, c);
	}
	printf("%d\n", EK());
	return 0;
}

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<math.h>
#include<map>
#include<sstream>
#include<deque>
#include<unordered_map>
using namespace std;

const int N = 1e3 + 5, M = 2e4 + 5;
int n, m, S, T;
int h[N], e[M],f[M], ne[M], idx;
int pre[N], d[N];
bool vis[N];

/*
使用EK算法的技巧：
1.我们使用链式前向星建的图，这里我们一开始就建好每条边的反向边，且每条边的反向边与正向边相邻，如 i=0 存正向边，那么 i=1 存反向边，这样求一条边的反向边只需要按为 取反即可
2.求最短路时，因为每条边的权值为 1 ，所以我们直接使用 bfs 求最短路即可
3.因为我们每次求完一条简单路径后需要将每单路径上的所有边都减去流量，反边加上流量，所以我们需要使用 pre 数组来存储前驱。这里 pre 存储边而非节点。

*/

void add(int a, int b, int c) {
	e[idx] = b, f[idx] = c, ne[idx] = h[a], h[a] = idx++;
	e[idx] = a, f[idx] = 0, ne[idx] = h[b], h[b] = idx++;
}

bool bfs() {
	queue<int>q;
	memset(vis, 0, sizeof vis);
	q.push(S);
	vis[S] = 1;
	d[S] = 1e8;
	while (!q.empty()) {
		int t = q.front();
		q.pop();
		for (int i = h[t]; i != -1; i = ne[i]) {
			int ver = e[i];
			if (!vis[ver]&&f[i]) {
				d[ver] = min(d[t], f[i]);
				pre[ver] = i;
				if (ver == T) { return 1; }
				q.push(ver);
				vis[ver] = 1;
			}
		}
	}
	return 0;
}

int EK() {
	int ret = 0;
	while (bfs()) {
		//cout << "LLLLLLLLLLL" << endl;
		ret += d[T];
		for (int i = T; i != S;i=e[pre[i]^1]) {
			f[pre[i]] -= d[T], f[pre[i]^1] += d[T];
		}
	}
	return ret;
}

int main() {
	scanf("%d%d%d%d", &n, &m, &S, &T);
	memset(h, -1, sizeof h);
	for (int i = 1,a,b,c; i <= m; i++) {
		scanf("%d%d%d", &a, &b, &c);
		add(a, b, c);
	}
	printf("%d\n", EK());

	return 0;
}

Dinic算法：

1.创建一个residual graph,初始的residual graph的每条边的容量等于原图边的容量
2.循环：
   a.构造level grahp（可以理解为层次遍历的图，保留层与层之间的边）
   b.在level grahp寻找阻塞流
   c.更新residual graph

时间复杂度 O(m*n^2):这说明Dinic算法通常比EK算法快