【ACWing】2172. Dinic/ISAP求最大流

题目地址：

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

给定一个包含$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 10000$
$1\le m\le 100000$
$0\le c\le 10000$
$S\ne T$

可以采用Dinic算法。这个算法是对EK算法的改进，但本质是一样的，也是在残留网络上面找增广路，但是不同于EK算法的地方是，它可以一次增广多条路，从而提高效率。其思路是这样的：
1、与EK算法一样，先构造残留网络；
2、接着从源点BFS，该BFS的作用是找增广路，并且将每个点按距离源点的边数做分层（其实就是像无权图求最短路的过程），求出分层数组$d$（$d[v]$就是$v$与源点$S$的最短路径边数，这里最短指的就是边数最少），同时初始化当前弧数组（这个数组的作用是判断某个点的第几条路还可以增加流量，从而略过已经无法增加流量的边，加速枚举边的过程）。当第一次遍历到汇点$T$的时候，说明找到了一条增广路，返回true，并且也将所有从$S$走$d[T]$步能到$T$的路径上的点的层数都求好了；如果找不到增广路则返回false；
3、只要BFS能找到增广路，就从$S$做DFS，该DFS的作用是搜索增广路，并求一下本次增广能增加多少流量。具体来说就是从$S$，走，每次只走$d$值增加$1$的点（意味着能走近$T$一步），并且每次也只走容量大于$0$的边。增加的流量的就是走的所有边的容量的最小值。在DFS的时候，同时要做一些优化：将已经满流的弧略过，更新当前弧数组；如果某个点向后走都找不到增加流量的路径了，那直接将这个点标记掉（直接令$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)$。