DAA | 网络流问题

在计算机科学中，网络流（英语：network flow）是一类问题，它涉及到一些链接节点的有向图，其中每条边都有一个容量，指定了从一个节点到另一个节点的最大流量。网络流问题通常涉及到在这个图上找到一个最大的流，使得每一条边上的流量都不超过该边的容量。网络流问题有很多应用，例如在网络流量控制中，它被用来优化网络带宽的使用。

解决网络流问题的算法

网络流问题有很多经典的算法，每个算法都有自己的优缺点。下面是一些通用的算法：

1. 最大流算法：在一个有向图中，从起点流向终点，求最大流，使用的算法包括Ford-Fulkerson算法，Edmonds-Karp算法和Dinic算法。

2. 最小割算法：把图分成两个部分，使得两部分之间的权值最小，常用的算法包括Karger算法和Stoer-Wagner算法。

3. 最大权匹配算法：在二分图中寻找使权值最大的匹配，包括匈牙利算法和KM算法。

实现网络流问题算法的代码片段

Ford-Fulkerson算法

Ford-Fulkerson算法是最早的最大流算法之一。它使用深度优先搜索来寻找增广路径，然后不断增加流量直到无法找到增广路径为止。以下是一个简单的Python实现：

def ford_fulkerson(graph, source, sink):
    def bfs(graph, s, t, parent):
        visited = [False] * len(graph)
        queue = [s]
        visited[s] = True
        while queue:
            u = queue.pop(0)
            for index, val in enumerate(graph[u]):
                if not visited[index] and val > 0:
                    visited[index] = True
                    parent[index] = u
                    queue.append(index)
        return visited[t]

    parent = [-1] * len(graph)
    max_flow = 0
    while bfs(graph, source, sink, parent):
        path_flow = float('inf')
        s = sink
        while s != source:
            path_flow = min(path_flow, graph[parent[s]][s])
            s = parent[s]
        max_flow += path_flow
        v = sink
        while v != source:
            u = parent[v]
            graph[u][v] -= path_flow
            graph[v][u] += path_flow
            v = parent[v]
    return max_flow

匈牙利算法

匈牙利算法是求解二分图最大匹配的经典算法之一。以下是一个简单的Python实现：

def hungarian(graph, matching, visited, i):
    for j in range(len(graph[0])):
        if graph[i][j] and not visited[j]:
            visited[j] = True
            if matching[j] == -1 or hungarian(graph, matching, visited, matching[j]):
                matching[j] = i
                return True
    return False

def max_weight_matching(graph):
    matching = [-1] * len(graph[0])
    for i in range(len(graph)):
        visited = [False] * len(graph[0])
        hungarian(graph, matching, visited, i)
    return matching

Dinic算法

Dinic算法是一种快速解决最大流问题的算法。它和Ford-Fulkerson算法类似，都是不断寻找增广路径，并增加流量。以下是一个简单的Python实现：

class Edge:
    def __init__(self, u, v, w):
        self.u = u
        self.v = v
        self.w = w

class Dinic:
    def __init__(self, n):
        self.adj = [[] for _ in range(n)]
        self.edges = []

    def add_edge(self, u, v, w):
        self.edges.append(Edge(u, v, w))
        self.edges.append(Edge(v, u, 0))
        m = len(self.edges)
        self.adj[u].append(m - 2)
        self.adj[v].append(m - 1)

    def bfs(self, s, t):
        self.level = [-1] * len(self.adj)
        self.level[s] = 0
        q = [s]
        for u in q:
            for eidx in self.adj[u]:
                v, w = self.edges[eidx].v, self.edges[eidx].w
                if w > 0 and self.level[v] == -1:
                    self.level[v] = self.level[u] + 1
                    q.append(v)
        return self.level[t] != -1

    def dfs(self, u, t, f):
        if u == t or not f:
            return f
        for eidx in self.adj[u]:
            v, w = self.edges[eidx].v, self.edges[eidx].w
            if w > 0 and self.level[v] == self.level[u] + 1:
                df = self.dfs(v, t, min(f, w))
                if df:
                    self.edges[eidx].w -= df
                    self.edges[eidx ^ 1].w += df
                    return df
        return 0

    def max_flow(self, s, t):
        flow = 0
        while self.bfs(s, t):
            while True:
                df = self.dfs(s, t, float('inf'))
                if df == 0:
                    break
                flow += df
        return flow

参考资料

• 维基百科 - 网络流
• 算法竞赛进阶指南
• 算法竞赛入门经典