网络流基本概念及实现算法

基本概念

流网络

对于一个有向图, 抽象成水管里的水的模型, 每根管子有容量限制, 计为$G=(V,E)$, 首先不考虑反向边

对于任意无向图, 都可以将反向边转化为上述形式

如果一条边不存在, 定义为容量为$0$, 形式上来说就是$c(u,v)=0$

可行流

对于每一个流网络考虑一个可行流$f$, 指定每条边的流量, 需要满足两个条件

• 容量限制 $0\le f(u,v)\le c(u,v)$
• 流量守恒, 对于每个点来说, 流进去多少, 流出来多少, 形式化来说

$$\sum _{(v,u)}f(v,u)=\sum _{(u,v)}f(u,v)$$
对于一个可行流, 从源点流向汇点的流量定义为$|f|$, 每秒从源点流出的流量, 或者流入汇点的流量, 每秒净往外流出的流量

$$|f|=\sum _{(s,v)}f(s,v)-\sum _{(v,s)}f(v,s)$$

最大流指的是流量值最大的可行流

残存网络

残存网络是对于流网络某一个可行流

对于某个可行流$f_1$, 残存网络$G_{f_1}$
残存网络的点集与原图完全一致$V_f=V$, 但是边集不仅包含原图的边还包含原图的反向边$E_f=E+E^{\prime }$

残存网络也是流网络

对于残存网络的容量记为$c^{\prime }(u,v)$

• 对于原图的边, 那么$c^{\prime }(u,v)=c(u,v)-f(u,v)$
• 对于原图的反向边, $c^{\prime }(u,v)=f(v,u)$

对于任意一个可行流$f$, 都可以求出残存网络$G_f$

记残存网络的可行流$f^{\prime }$, $f+f^{\prime }$也是原来流网络$G$的一个可行流

新的流的流量值等于两个流的流量值之和 $|f+f^{\prime }|=|f|+|f^{\prime }|$, 流量相加等同于每条边相加

为什么新的流是原流网络$G$的可行流?

• 是否满足容量限制
• 是否满足流量守恒

增广路径

在残存网络中, 从源点出发沿着**容量大于$0$**的点走如果能走到汇点, 那么这一条路径就是增广路径

上述红色路径就是增广路径, 增广路径一定是一个可行流, 流量大于$0$
如果$G_f$总不存在增广路径, 断言$f$是原来流网络的最大流

割

将点集$V$分为两个集合$S,T$, 满足以下条件

• $s\in S$, $t\in T$
• $S\cup T=V$, $S\cap T=\varnothing$

上述就是割的形式化描述

割的容量

所有从$S$指向$T$的边, 被称为割的容量, 容量不考虑回来的边

$$c(S,T)=\sum _{u\in S,v\in T}c(u,v)$$

割的流量

所有从$S$留到$T$的流量减去从$T$流向$S$的流量, 也就是净流量

$$f(S,T)=\sum _{u\in S,v\in T}f(u,v)-\sum _{u\in T,v\in S}f(u,v)$$

对于一个流网络来说, 如果流网络确定, 那么割的容量确定, 但是因为一个流网络存在多个可行流, 因此割的流量是取决于每个可行流的流量的

性质1: 最小割指的是最小割的容量, 对于任意一个割以及任意一个可行流, 割的流量小于等于割的容量, 形式化来说$f(S,T)\le c(S,T)$, 证明过程如下

性质2: 对于流网络的任意一个割和任意一个可行流都有 $f(S,T)=|f|$

根据性质1和性质2推出$|f|=f(S,T)\le c(S,T)$, 也就推出$|f|\le c(S,T)$, 也就是最大流小于等于最小割

最大流最小割定理

对于某个流网络$G=(V,E)$, 以下三个结论相互等价

1. 可行流$f$是最大流
2. $f$的残存网络中不存在增广路径
3. 存在割$[S,T]$, 使得$c(S,T)=|f|$

证明如下

$1$推$2$
反证法, 存在增广路径, 由上述增广路径定理可知, 当前可行流不是最大流

$3$推$1$
因为$|f|\le c(S,T)$, 对于结论$3$, 存在一个割使得$|f|=c(S,T)$, 证明$f$是否是最大流
$最大流\ge |f|$, 又因为$|f|=c(S,T)\ge 最大流$, 因此$f$是最大流

由结论$3$得知, $最小割\le c(S,T)=|f|\le 最大流$, 也就有最小割小于等于最大流, 上述性质2可知, 最大流小于等于最小割, 因此最大流等于最小割

$2$推$3$
如果当前残存网络不存在增广路径, 能否构造出一个割, 使得$c(S,T)=|f|$
构造一个合法的割
点集$S$是在$G_f$中$s$沿着容量大于$0$的边走, 走到的所有点, 因为不存在增广路径, 因此$s$走不到$t$
点集$T$是$V-S$
借助的$G_f$构造的是原网络$G$里的割

判断当前割的容量是否等于$|f|$

构造的割的性质如下

1. $f(x,y)=c(x,y)$
2. $f(a,b)=0$

对于性质1, 如果$f(x,y)<c(x,y)$, 那么在残存网络中仍然会有$x$连到$y$的边, 也就$x$能遍历到, $y\in S$, 与我们构造的矛盾
对于性质2, 如果$f(a,b)>0$, 那么在残存网络中也是能遍历到, $a\in S$, 与我们构造的矛盾

$$|f|=\sum _{u\in S,v\in T}f(u,v)-\sum _{u\in T,v\in S}f(u,v)$$

因为没有反向边, 并且每个边的流量等于边的容量, 因此

$$|f|=\sum _{u\in S,v\in T}c(u,v)=c(S,T)$$

最大流最小割定理证毕

最大流算法实现

$Ford–Fulkerson$方法

求最大流的贪心方法, 维护残存网络, 不断的在残存网络中寻找增广路径, 将当前流变为$f+f^{\prime }$, 然后在新的流的残存网络中继续寻找增广路径, 将当前残存网络$G_f$变为$G_{f+f^{\prime }}$

上图是残存网络中更新的过程, $k$是路径的流量, 也就是所有边容量的最小值, 然后更新所有边的容量

$Edmonds–Karp$算法求最大流

时间复杂度$O(n{m}^2)$

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 1010, M = 20010, INF = 0x3f3f3f3f;

int n, m, s_node, t_node;
int head[N], edge_end[M], next_edge[M], w[M], edge_index;
int q[N], pre[N], min_val[N];
bool vis[N];

void add(int ver1, int ver2, int val) {
    edge_end[edge_index] = ver2, next_edge[edge_index] = head[ver1], w[edge_index] = val, head[ver1] = edge_index++;
}

bool bfs() {
    memset(vis, false, sizeof vis);

    int h = 0, t = -1;
    q[++t] = s_node;
    vis[s_node] = true;
    min_val[s_node] = INF;

    while (h <= t) {
        int u = q[h++];
        for (int i = head[u]; ~i; i = next_edge[i]) {
            int ver = edge_end[i];
            if (!vis[ver] && w[i]) {
                vis[ver] = true;
                min_val[ver] = min(min_val[u], w[i]);
                pre[ver] = i;
                if (ver == t_node) return true;
                q[++t] = ver;
            }
        }
    }

    return false;
}

int edmonds_karp() {
    int res = 0;

    while (bfs()) {
        int val = min_val[t_node];
        res += val;

        for (int i = t_node; i != s_node; i = edge_end[pre[i] ^ 1]) {
            w[pre[i]] -= val;
            w[pre[i] ^ 1] += val;
        }
    }

    return res;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);

    memset(head, -1, sizeof head);
    cin >> n >> m >> s_node >> t_node;

    while (m--) {
        int u, v, w;
        cin >> u >> v >> w;
        add(u, v, w);
        add(v, u, 0);
    }

    int res = edmonds_karp();

    cout << res << "\n";
    return 0;
}

$Dinic$算法求最大流

将所有能够增广的路径全部计算, 因为可能有环, 因此使用分层图优化, 路径只能从前一层走到后一层
分层图 + 当前弧优化
时间复杂度$O(n^{2}m)$

从起点到终点, 可以流$limit$的流量, 搜索从当前点开始到终点能流的流量

假设在搜索到终点后流量$f_i<limit$, 说明$f_i$一定会满流, 那么在下一次搜索的时候不需要搜索该边

而是从下一条边开始搜, 代码表示为$curr[u]=i$

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 10010, M = 200010, INF = 0x3f3f3f3f;

int n, m, s_node, e_node;
int head[N], edge_end[M], next_edge[M], w[M], edge_index;
int q[N], layer[N], curr[N];

void add(int ver1, int ver2, int val) {
	edge_end[edge_index] = ver2, next_edge[edge_index] = head[ver1], w[edge_index] = val, head[ver1] = edge_index++;
}

bool bfs() {
	memset(layer, -1, sizeof layer);

	int h = 0, t = -1;
	q[++t] = s_node;
	layer[s_node] = 0;
	curr[s_node] = head[s_node];

	while (h <= t) {
		int u = q[h++];

		for (int i = head[u]; ~i; i = next_edge[i]) {
			int ver = edge_end[i];

			if (layer[ver] == -1 && w[i]) {
				layer[ver] = layer[u] + 1;
				curr[ver] = head[ver];
				if (ver == e_node) return true;
				q[++t] = ver;
			}
		}
	}

	return false;
}

int dfs(int u, int limit) {
	if (u == e_node) return limit;

	// 从当前点向后流的流量
	int flow = 0;
	for (int i = curr[u]; ~i && flow < limit; i = next_edge[i]) {
		int ver = edge_end[i];

		// i前面的边都用完了, 当前弧更新为i
		curr[u] = i;
		if (layer[ver] == layer[u] + 1 && w[i]) {
			int val = dfs(ver, min(w[i], limit - flow));
			if (!val) layer[ver] = -1;

			w[i] -= val;
			w[i ^ 1] += val;
			flow += val;
		}
	}
	return flow;
}

int dinic() {
	int res = 0, flow;
	while (bfs()) {
		// 搜索增广路径并且累计全部的流量
		while ((flow = dfs(s_node, INF))) {
			res += flow;
		}
	}

	return res;
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	memset(head, -1, sizeof head);
	cin >> n >> m >> s_node >> e_node;
	while (m--) {
		int u, v, w;
		cin >> u >> v >> w;
		add(u, v, w);
		add(v, u, 0);
	}

	int res = dinic();
	cout << res << "\n";

	return 0;
}