在流网络中找到最小 st 割

介绍

最小割（Minimum Cut）是图论中的一种经典问题，它描述了在一个给定的加权无向图中，找到一些最小的边集，使得在删除这些边之后，原图不再连通。最小割通常被用来解决最大流（Maximum Flow）问题，因为它与最大流问题存在着紧密的联系。

在流网络中，最小 st 割（Minimum s-t Cut）通常被用来描述从源点 s 到汇点 t 的最小流量。一个流网络可以被看作一个有向图，其中每一条边都有一个非负权值表示其容量，表示该边所能够承载的最大流量。最小 st 割问题可以被看作是在流网络中找到一些最小的边集，使得在删除这些边之后，使得从源点 s 到汇点 t 不再连通，并且在删除这些边之后，原网络中 s 和 t 之间不会再有任何通路。

算法

现在我们来探讨最小 st 割问题的算法。我们有多种方法来解决这个问题，其中最常见的算法之一是 Edmonds-Karp 算法。该算法是基于广度优先搜索（BFS）的最短增广路径（Shortest Augmenting Path）方法，在每次增广中寻找从源点 s 到汇点 t 的一条最短路，并将沿途所经过的边的容量减去当前的流量，然后再将这些边的反向边的容量增加相同的流量。通过这种方式，我们可以不断地增加流量，同时我们每次增加的流量都是目前最小割的一部分，因此可以最终找到最小割。

下面是 Edmonds-Karp 算法的伪代码：

1. 初始化流网络的流量为 0
2. 循环执行以下步骤，直到无法找到增广路为止：
   a. 利用 BFS 查找从源点 s 到汇点 t 的一条最短路，并记录该路径上能够承受的最大流量 f
   b. 更新流网络中的各个边的容量，将其减去 f，同时将其反向边的容量增加 f
   c. 将当前的流量加上 f
3. 返回现在的流量作为最小 st 割

代码实现

下面是使用 Python 语言实现的 Edmonds-Karp 算法的代码：

from typing import List

INF = float("inf")


class Edge:
    def __init__(self, to: int, capacity: int, rev: int):
        self.to = to
        self.capacity = capacity
        self.rev = rev


class MaxFlow:
    def __init__(self, n: int):
        self.n = n
        self.graph: List[List[Edge]] = [[] for _ in range(n)]
        self.level = [0] * n
        self.iter = [0] * n

    def add_edge(self, frm: int, to: int, capacity: int):
        self.graph[frm].append(Edge(to, capacity, len(self.graph[to])))
        self.graph[to].append(Edge(frm, 0, len(self.graph[frm]) - 1))

    def bfs(self, s: int):
        from collections import deque
        que = deque()
        self.level = [-1] * self.n
        self.level[s] = 0
        que.append(s)
        while que:
            v = que.popleft()
            for e in self.graph[v]:
                if e.capacity > 0 and self.level[e.to] < 0:
                    self.level[e.to] = self.level[v] + 1
                    que.append(e.to)

    def dfs(self, v: int, t: int, f: int):
        if v == t:
            return f
        for i in range(self.iter[v], len(self.graph[v])):
            e = self.graph[v][i]
            if e.capacity > 0 and self.level[v] < self.level[e.to]:
                d = self.dfs(e.to, t, min(f, e.capacity))
                if d > 0:
                    e.capacity -= d
                    self.graph[e.to][e.rev].capacity += d
                    return d
            self.iter[v] += 1
        return 0

    def max_flow(self, s: int, t: int):
        flow = 0
        while True:
            self.bfs(s)
            if self.level[t] == -1:
                break
            self.iter = [0] * self.n
            while True:
                f = self.dfs(s, t, INF)
                if f == 0:
                    break
                flow += f
        return flow

    def min_cut(self, s: int, t: int):
        self.max_flow(s, t)
        cut = []
        for v in range(self.n):
            for e in self.graph[v]:
                if e.capacity == 0:
                    cut.append((v, e.to))
        return cut

总结

最小 st 割算法是最大流算法的一种应用，它为解决最大流问题提供了重要的信息。通过 Edmonds-Karp 算法，我们可以轻松地在流网络中找到最小的 st 割。在实际应用中，我们可以利用最小 st 割算法来解决各种问题，如计算通信网络的带宽、路由器的负载均衡等等。