题目地址:
https://www.acwing.com/problem/content/2174/
给定一个包含 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
≤
10000
2≤n≤10000
2≤n≤10000
1
≤
m
≤
100000
1≤m≤100000
1≤m≤100000
0
≤
c
≤
10000
0≤c≤10000
0≤c≤10000
S
≠
T
S≠T
S=T
可以采用Dinic算法。这个算法是对EK算法的改进,但本质是一样的,也是在残留网络上面找增广路,但是不同于EK算法的地方是,它可以一次增广多条路,从而提高效率。其思路是这样的:
1、与EK算法一样,先构造残留网络;
2、接着从源点BFS,该BFS的作用是找增广路,并且将每个点按距离源点的边数做分层(其实就是像无权图求最短路的过程),求出分层数组
d
d
d(
d
[
v
]
d[v]
d[v]就是
v
v
v与源点
S
S
S的最短路径边数,这里最短指的就是边数最少),同时初始化当前弧数组(这个数组的作用是判断某个点的第几条路还可以增加流量,从而略过已经无法增加流量的边,加速枚举边的过程)。当第一次遍历到汇点
T
T
T的时候,说明找到了一条增广路,返回true,并且也将所有从
S
S
S走
d
[
T
]
d[T]
d[T]步能到
T
T
T的路径上的点的层数都求好了;如果找不到增广路则返回false;
3、只要BFS能找到增广路,就从
S
S
S做DFS,该DFS的作用是搜索增广路,并求一下本次增广能增加多少流量。具体来说就是从
S
S
S,走,每次只走
d
d
d值增加
1
1
1的点(意味着能走近
T
T
T一步),并且每次也只走容量大于
0
0
0的边。增加的流量的就是走的所有边的容量的最小值。在DFS的时候,同时要做一些优化:将已经满流的弧略过,更新当前弧数组;如果某个点向后走都找不到增加流量的路径了,那直接将这个点标记掉(直接令
d
[
v
]
=
−
1
d[v]=-1
d[v]=−1),以后都不用走;只有累加的流量还没达到本层DFS搜索的流量上界的时候才继续找增广路,这个流量上界主要被路径上的边容量最小值决定。每次找到增广路增加流之后,记得更新残留网络。
4、直到BFS找不到增广路的时候,说明流无法再增加了,最大流已经求得,返回之。
代码如下:
#include <iostream>
#include <cstring>
using namespace std;
const int N = 10010, M = 200010, INF = 1e8;
int n, m, S, T;
int h[N], e[M], f[M], ne[M], idx;
// q是队列,d是每个点在bfs中的层数(深度),
// cur[i]代表从i这个点的哪条弧开始搜(cur[i]之前的弧都流量满了)
int q[N], d[N], cur[N];
// 建残留网络的边
void add(int a, int b, int c) {
e[idx] = b, ne[idx] = h[a], f[idx] = c, h[a] = idx++;
e[idx] = a, ne[idx] = h[b], f[idx] = 0, h[b] = idx++;
}
// 进行bfs,从源点开始搜,记录每层的点的层数,并初始化当前弧数组cur,搜到汇点就返回,说明找到了增广路
bool bfs() {
int hh = 0, tt = 0;
memset(d, -1, sizeof d);
q[tt++] = S, d[S] = 0, cur[S] = h[S];
while (hh < tt) {
int t = q[hh++];
for (int i = h[t]; ~i; i = ne[i]) {
int v = e[i];
// 只走之前没走过的点,并且只走容量为正的弧(因为增广路路径上的边容量都是正的)
if (d[v] == -1 && f[i]) {
d[v] = d[t] + 1;
if (v == T) return true;
cur[v] = h[v];
q[tt++] = v;
}
}
}
return false;
}
// 从点u开始走,在容量限制不超过limit的情况下,最多能多流多少流
int dfs(int u, int limit) {
// 如果已经到达汇点了,那么limit的流都能流,返回limit
if (u == T) return limit;
int flow = 0;
// 只从点u的当前弧开始搜边,并且如果flow < limit(即还能增加流量)才继续搜
for (int i = cur[u]; ~i && flow < limit; i = ne[i]) {
// 更新当前弧,走到这里的时候说明i前面的弧都满了,不需要搜了
cur[u] = i;
int v = e[i];
// 只走离汇点更近的点,并且只走容量大于0的点
if (d[v] == d[u] + 1 && f[i]) {
int t = dfs(v, min(f[i], limit - flow));
// 如果从v走不能增加流量了,那么v这个点以后再也不用访问了,将其层数设为-1使得以后不会再走v
if (!t) d[v] = -1;
// 更新残留网络
f[i] -= t, f[i ^ 1] += t, flow += t;
}
}
return flow;
}
int dinic() {
int r = 0, flow;
// 先bfs一下看有没有增广路,如果有的话从S开始搜所有长度为S到T最短路的增广路,并累加流量
while (bfs()) while (flow = dfs(S, INF)) r += flow;
return r;
}
int main() {
scanf("%d%d%d%d", &n, &m, &S, &T);
memset(h, -1, sizeof h);
while (m--) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
printf("%d\n", dinic());
return 0;
}
时间复杂度 O ( n 2 m ) O(n^2m) O(n2m),空间 O ( n ) O(n) O(n)。