题目地址:
https://www.acwing.com/problem/content/2173/
给定一个包含 n n n个点 m m m条边的有向图,并给定每条边的容量,边的容量非负。图中可能存在重边和自环。求从点 S S S到点 T T T的最大流。
输入格式:
第一行包含四个整数
n
,
m
,
S
,
T
n,m,S,T
n,m,S,T。接下来
m
m
m行,每行三个整数
u
,
v
,
c
u,v,c
u,v,c,表示从点
u
u
u到点
v
v
v存在一条有向边,容量为
c
c
c。点的编号从
1
1
1到
n
n
n。
输出格式:
输出点
S
S
S到点
T
T
T的最大流。如果从点
S
S
S无法到达点
T
T
T则输出
0
0
0。
数据范围:
2
≤
n
≤
1000
2≤n≤1000
2≤n≤1000
1
≤
m
≤
10000
1≤m≤10000
1≤m≤10000
0
≤
c
≤
10000
0≤c≤10000
0≤c≤10000
S
≠
T
S≠T
S=T
EK算法(Edmond-Karp算法)求最大流是Ford-Fulkerson方法的一种实现。它依赖于两个定理,一个是,对于一个流网络
G
G
G上的网络流
f
f
f,其残留网络的一个可行流
f
′
f'
f′,
f
+
f
′
f+f'
f+f′也是个可行流;另一个是,
f
f
f是最大流等价于其残留网络
G
f
G_f
Gf不存在增广路。增广路的意思是,在
f
f
f的残留网络
G
f
G_f
Gf里,从源点
s
s
s开始走,每一步都走一个边权为正的边(即容量大于
0
0
0的边),并走到了汇点
t
t
t的一条路径。所以要求最大流,本质上就是要在残留网络里找增广路,一旦找到了增广路,就找到了残留网络里的一条流量为正的可行流(即沿着增广路开一条流量为路径上最小容量的可行流即可),将这个可行流加到
f
f
f上即得到了一个更大的流。如此这般,直到残留网络里找不到增广路了为止。而找增广路,可以直接用BFS来做,这就是EK算法。具体代码步骤如下:
1、先建图。注意代码里只维护残留网络,不维护原网络。建图的时候用链式前向星来建。一开始建图的时候,直接正向边和反向边都建出来(这里正向边指的是与原流网络方向相同的边,反向边指的是与原流网络方向相反的边),并且按照先建正向边后建反向边的顺序来做,那么如果某条边的下标是idx
,那么其相反边的下标就是idx ^ 1
(因为正向边的下标是
0
,
2
,
4
,
.
.
.
0,2,4,...
0,2,4,...,而反向边的下标是
1
,
3
,
5
1,3,5
1,3,5)。一开始建的残留网络实际上对应的原图可行流是
0
0
0流。所以正向边的容量就是原图容量,反向边的容量是
0
0
0;
2、建好残留网络的图之后,原图的有个可行流是
0
0
0,我们用BFS找残留网络的一条增广路,同时在找的过程中,需要记录走到当前点为止,路径上的最小容量(这将是增广路对应的残留网络的可行流的流量),以及每个点的入边(之所以存边,是因为如果pre[v] = i
,即点v
的入边下标是i
,那么这条边的反向边的下标就是i ^ 1
,那么其前驱点的编号就是e[i ^ 1]
,这样就能巧妙地找到路径上每个点的前驱顶点。不这么做的话是很难找到前驱节点的);
3、找到一条增广路之后,在原图已经得到的可行流里累加这个增广路上的流
f
′
f'
f′,并更新残留网络。根据残留网络的定义,残留网络增广路上的正向边的容量都将减少
∣
f
′
∣
|f'|
∣f′∣,而残留网络增广路上的反向边的容量都将增加
∣
f
′
∣
|f'|
∣f′∣。从汇点
t
t
t出发,沿着pre
数组一步步向前找到增广路的每条边,更新它们即可;
4、当找不到增广路的时候算法终止。累加出的流量即为最大流流量。
代码如下:
#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
// 要开两倍的边,因为正向边和反向边都要开
const int N = 1010, M = 20010, INF = 1e8;
int n, m, S, T;
// 以下数组都是在维护残留网络。f[i]指下标为i的边的容量
int h[N], e[M], f[M], ne[M], idx;
// d[v]是指在bfs找增广路的时候,走到点v为止,所有边的最小边权(容量);
// pre[v]是指在bfs找增广路的时候,v的入边的下标
int d[N], pre[N];
bool st[N];
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(st, 0, sizeof st);
q.push(S), st[S] = true, d[S] = INF;
while (q.size()) {
int t = q.front(); q.pop();
for (int i = h[t]; ~i; i = ne[i]) {
int v = e[i];
// 如果v没遍历过,并且走到v的这条边的容量为正,那么就向v走一步
if (!st[v] && f[i]) {
st[v] = true;
d[v] = min(d[t], f[i]);
pre[v] = i;
if (v == T) return true;
q.push(v);
}
}
}
return false;
}
int EK() {
int res = 0;
while (bfs()) {
res += 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 res;
}
int main() {
cin >> n >> m >> S >> T;
memset(h, -1, sizeof h);
while (m--) {
int a, b, c;
cin >> a >> b >> c;
add(a, b, c);
}
cout << EK() << endl;
return 0;
}
时间复杂度 O ( n m 2 ) O(nm^2) O(nm2),空间 O ( n ) O(n) O(n)。