【ACWing】2171. EK求最大流

题目地址：

https://www.acwing.com/problem/content/2173/

给定一个包含$n$个点$m$条边的有向图，并给定每条边的容量，边的容量非负。图中可能存在重边和自环。求从点$S$到点$T$的最大流。

输入格式：
第一行包含四个整数$n,m,S,T$。接下来$m$行，每行三个整数$u,v,c$，表示从点$u$到点$v$存在一条有向边，容量为$c$。点的编号从$1$到$n$。

输出格式：
输出点$S$到点$T$的最大流。如果从点$S$无法到达点$T$则输出$0$。

数据范围：
$2\le n\le 1000$
$1\le m\le 10000$
$0\le c\le 10000$
$S\ne T$

EK算法（Edmond-Karp算法）求最大流是Ford-Fulkerson方法的一种实现。它依赖于两个定理，一个是，对于一个流网络$G$上的网络流$f$，其残留网络的一个可行流$f^{\prime }$，$f+f^{\prime }$也是个可行流；另一个是，$f$是最大流等价于其残留网络$G_f$不存在增广路。增广路的意思是，在$f$的残留网络$G_f$里，从源点$s$开始走，每一步都走一个边权为正的边（即容量大于$0$的边），并走到了汇点$t$的一条路径。所以要求最大流，本质上就是要在残留网络里找增广路，一旦找到了增广路，就找到了残留网络里的一条流量为正的可行流（即沿着增广路开一条流量为路径上最小容量的可行流即可），将这个可行流加到$f$上即得到了一个更大的流。如此这般，直到残留网络里找不到增广路了为止。而找增广路，可以直接用BFS来做，这就是EK算法。具体代码步骤如下：
1、先建图。注意代码里只维护残留网络，不维护原网络。建图的时候用链式前向星来建。一开始建图的时候，直接正向边和反向边都建出来（这里正向边指的是与原流网络方向相同的边，反向边指的是与原流网络方向相反的边），并且按照先建正向边后建反向边的顺序来做，那么如果某条边的下标是idx，那么其相反边的下标就是idx ^ 1（因为正向边的下标是$0,2,4,...$，而反向边的下标是$1,3,5$）。一开始建的残留网络实际上对应的原图可行流是$0$流。所以正向边的容量就是原图容量，反向边的容量是$0$；
2、建好残留网络的图之后，原图的有个可行流是$0$，我们用BFS找残留网络的一条增广路，同时在找的过程中，需要记录走到当前点为止，路径上的最小容量（这将是增广路对应的残留网络的可行流的流量），以及每个点的入边（之所以存边，是因为如果pre[v] = i，即点v的入边下标是i，那么这条边的反向边的下标就是i ^ 1，那么其前驱点的编号就是e[i ^ 1]，这样就能巧妙地找到路径上每个点的前驱顶点。不这么做的话是很难找到前驱节点的）；
3、找到一条增广路之后，在原图已经得到的可行流里累加这个增广路上的流$f^{\prime }$，并更新残留网络。根据残留网络的定义，残留网络增广路上的正向边的容量都将减少$|f^{\prime }|$，而残留网络增广路上的反向边的容量都将增加$|f^{\prime }|$。从汇点$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(n)$。