【图论】从中国邮递员问题到平面图最大割：多项式时间算法的实践与优化

1. 从送信到扫雪：中国邮递员问题的前世今生

大家好，我是老张，在算法和图论这个领域摸爬滚打了十几年。今天想和大家聊聊两个听起来有点“古老”但极其精妙的问题：中国邮递员问题和平面图最大割问题。你可能觉得这俩问题八竿子打不着，一个是邮递员怎么走路最短，一个是给图“切一刀”怎么切出的边最多。但有意思的是，它们的核心算法思想，尤其是那个将问题转化为“匹配”的巧思，简直如出一辙。这就像武侠小说里，少林和武当的武功路数看似不同，但内功心法却可以相互印证。我打算用最接地气的方式，结合我这些年踩过的坑和优化过的代码，带大家走一遍这两个问题的多项式时间算法之旅。无论你是正在刷题准备面试的算法新人，还是想深入理解图论经典问题的研究者，相信都能从这篇“实战笔记”里挖到点干货。

咱们先从一个非常生活化的问题开始。想象一下，你是一名邮递员，或者是一辆扫雪车的司机。你的任务是从仓库出发，走遍负责区域的所有街道（每条街至少一次），最后回到仓库。你肯定想走最短的路，省点油钱或者早点下班。这就是著名的中国邮递员问题，由我国学者管梅谷先生在1960年提出。把地图抽象一下，街道交叉口是“点”，街道是“边”，街道长度是边的“权重”，问题就变成了：在一个连通的无向带权图中，找到一条经过所有边至少一次、最终回到起点的最短回路。

那最理想的情况是什么？是这个图本身就能“一笔画”，也就是存在欧拉回路。一个图有欧拉回路的充要条件是所有顶点的度数（连接的边数）都是偶数。如果满足这个条件，恭喜你，直接找一条欧拉回路走一遍，每条边只走一次，就是最短路径，问题秒解。但现实很骨感，大部分地图都有很多“丁”字路口（度数为奇数的顶点），这时候你就不得不把某些街道重复走一遍。问题的核心就变成了：最少重复走哪些边，才能让整个图“变成”所有顶点度数为偶数的图？ 重复走的边的总长度要最小。

我最早接触这个问题时，直觉想法是暴力搜索，但稍微大点的图就算不动了。后来才知道，管梅谷先生提出的“奇偶点图上作业法”虽然开创先河，但复杂度较高。而在实际工程和算法竞赛中，我们更常用的是Edmonds-Johnson算法。这个算法的核心洞察非常漂亮：既然奇度数顶点一定有偶数个，那么我们的任务就是给这些奇顶点“配对”。每配对一对奇顶点，我们就在它们之间复制一条最短路径（相当于邮递员把这条路径走两遍）。这样，这两个奇顶点的度数各加1变成偶数，而路径中间经过的顶点度数都加2，奇偶性不变。最终，所有顶点都变成了偶度数。而我们要做的，就是找到一种配对方式，让所有被复制的路径长度之和最小。看，这是不是瞬间变成了一个我们熟悉的问题？——在一个由所有奇顶点构成的完全图中，求一个最小权完美匹配。匹配算法（如经典的Edmonds开花算法）是多项式时间的，这样一来，整个中国邮递员问题也就在多项式时间内解决了。

2. Edmonds-Johnson算法：手把手实现与优化技巧

理论听起来很美，但实现起来细节不少。下面我结合一个自己写过的例子，带大家走一遍完整的流程，并分享几个让算法跑得更快的优化点。

2.1 算法步骤拆解与代码实现

假设我们有一个带权无向图，用邻接矩阵表示。算法的第一步是找出所有度数为奇数的顶点。这个很简单，遍历一遍就能得到。

def find_odd_vertices(adj_matrix):
    """
    根据邻接矩阵找出所有奇度数顶点。
    adj_matrix: n x n 的列表，adj_matrix[i][j]为权重，0表示无边。
    """
    n = len(adj_matrix)
    degrees = [0] * n
    for i in range(n):
        for j in range(n):
            if adj_matrix[i][j] > 0:
                degrees[i] += 1
    odd_vertices = [i for i, d in enumerate(degrees) if d % 2 == 1]
    return odd_vertices

第二步，计算这些奇顶点两两之间的最短路径长度。这里我们用Floyd-Warshall算法计算全源最短路径，因为它写起来简单，对于不是特别大的图（比如几百个顶点）完全够用。当然，如果你知道奇顶点的数量很少，也可以用多次Dijkstra算法，可能更快。

def floyd_warshall(adj_matrix):
    """Floyd-Warshall全源最短路，返回距离矩阵dist。"""
    n = len(adj_matrix)
    dist = [[float('inf')] * n for _ in range(n)]
    for i in range(n):
        dist[i][i] = 0
        for j in range(n):
            if adj_matrix[i][j] > 0:
                dist[i][j] = adj_matrix[i][j]
    for k in range(n):
        for i in range(n):
            for j in range(n):
                if dist[i][k] + dist[k][j] < dist[i][j]:
                    dist[i][j] = dist[i][k] + dist[k][j]
    return dist

第三步，用奇顶点集合和它们之间的最短距离，构造一个完全图，然后求其最小权完美匹配。这是算法的核心，也是实现中最有挑战的部分。我们可以使用networkx库的max_weight_matching函数（注意它求最大权匹配，所以我们需要将权重取负）。或者，如果你追求纯手写实现，可以尝试实现Edmonds的开花算法，但那比较复杂。我这里用networkx演示：

import networkx as nx

def minimum_weight_perfect_matching(odd_vertices, dist):
    """
    在奇顶点构成的完全图中求最小权完美匹配。
    odd_vertices: 奇顶点索引列表。
    dist: 全源最短路距离矩阵。
    返回匹配对列表，如 [(i1, j1), (i2, j2), ...]
    """
    G = nx.Graph()
    m = len(odd_vertices)
    # 添加边，权重为负的距离（因为networkx求最大权匹配）
    for i in range(m):
        for j in range(i+1, m):
            u, v = odd_vertices[i], odd_vertices[j]
            G.add_edge(i, j, weight=-dist[u][v])
    # 求最大权匹配
    matching = nx.max_weight_matching(G, maxcardinality=True)
    # 将匹配索引转换回原图的顶点索引
    result = []
    for a, b in matching:
        result.append((odd_vertices[a], odd_vertices[b]))
    return result

第四步，根据匹配结果，在原图中复制对应的最短路径上的边。这里需要记录路径本身，而不仅仅是长度。我们可以在Floyd-Warshall算法中同时记录前驱节点来重构路径。第五步，在添加了重复边的新图（多重图）中，寻找一条欧拉回路。这可以用经典的Fleury算法或者更高效的Hierholzer算法。Hierholzer算法复杂度是线性的，我强烈推荐：

def hierholzer_eulerian_circuit(multigraph_adj):
    """
    在多重图中寻找欧拉回路（假设图已满足欧拉图条件）。
    multigraph_adj: 邻接表，list of list of (neighbor, edge_id)。
    返回顶点遍历序列。
    """
    from collections import deque
    circuit = deque()
    stack = [0]  # 从任意顶点开始，这里假设0存在
    while stack:
        v = stack[-1]
        if multigraph_adj[v]:
            u, _ = multigraph_adj[v].pop()
            # 删除反向边（因为是无向图）
            # 这里需要根据edge_id找到并删除对应边，具体实现取决于数据结构
            # 简化起见，假设我们能在邻接表中直接移除
            # multigraph_adj[u] = [(x, eid) for x, eid in multigraph_adj[u] if x != v]
            stack.append(u)
        else:
            circuit.appendleft(stack.pop())
    return list(circuit)

2.2 性能优化与踩坑记录

在实际项目中，直接套用上述模板可能会遇到性能瓶颈。第一个坑是Floyd-Warshall的O(n³)复杂度。当图顶点数上千时，这个开销就很大了。优化方法是，我们只关心奇顶点之间的最短路径。因此，可以以每个奇顶点为源点，运行一次Dijkstra算法（如果边权非负），这样复杂度是O(k * (E log V))，其中k是奇顶点数量，通常远小于V。如果图是稀疏的，这个优化效果非常显著。

第二个坑在于最小权完美匹配的实现。手写Edmonds开花算法非常复杂，容易出错。在大多数实际应用和竞赛中，如果奇顶点数量不多（比如少于50），甚至可以用状态压缩动态规划来求解匹配问题，代码更简洁可控。状态dp[mask]表示当前匹配了mask集合中的顶点时的最小代价，转移时枚举两个未匹配的顶点进行配对。

def min_cost_matching_dp(odd_vertices, dist):
    """使用状态压缩DP求解最小权完美匹配，适用于奇顶点数较少的情况（如<=20）。"""
    m = len(odd_vertices)
    size = 1 << m
    dp = [float('inf')] * size
    dp[0] = 0
    # 预处理两点间代价
    cost = [[0]*m for _ in range(m)]
    for i in range(m):
        for j in range(m):
            cost[i][j] = dist[odd_vertices[i]][odd_vertices[j]]
    for mask in range(size):
        if bin(mask).count('1') % 2: continue # 已匹配的顶点数为奇数，状态无效
        # 找一个未匹配的顶点i
        i = 0
        while i < m and (mask >> i) & 1:
            i += 1
        if i >= m: continue
        # 尝试将i与另一个未匹配的顶点j配对
        for j in range(i+1, m):
            if not (mask >> j) & 1:
                new_mask = mask | (1 << i) | (1 << j)
                dp[new_mask] = min(dp[new_mask], dp[mask] + cost[i][j])
    return dp[size-1]

第三个容易忽略的细节是重构重复边路径。Floyd-Warshall算法给出的只有距离，我们需要知道具体路径来复制边。一个实用的方法是，在跑最短路时，维护一个next矩阵，next[i][j]表示从i到j的最短路径上，i的下一个顶点是什么。这样就能快速递归地重构出整条路径。

3. 平面图最大割：另一个视角下的“奇偶配对”

聊完了送信问题，我们切换一下脑筋，来看一个看似完全不同的问题：最大割。给定一个无向图，把顶点分成两组S和T，横跨在两组之间的边叫做割边。最大割就是寻找一种分割方法，使得割边的数量最多。这个问题在一般图上是NP难的，意味着很可能没有多项式时间的精确算法。但是，在一种特殊的图——平面图（可以画在平面上使得边不相交的图）上，最大割问题却存在漂亮的多项式时间算法。这个算法由Hadlock在1975年提出，其核心思想，居然和中国邮递员问题有着惊人的相似性。

为什么平面图特殊呢？我们最希望图是个二分图，因为二分图的所有边都可以成为割边（只要把两个部分分别放入S和T）。一个图是二分图当且仅当它不包含奇圈（长度为奇数的环）。平面图有一个很好的性质，它的面（由边围成的区域）的边界是圈。如果所有面的次数（边界边数）都是偶数，那么这个平面图就是二分图，最大割边数就是总边数，问题直接解决。

麻烦出在奇面（边界为奇圈的面）上。奇面的存在意味着图不是二分图，必然有一些边无法成为割边。那么，为了得到最大割，我们的策略就是：删除尽可能少的边，破坏掉所有的奇圈，使得剩下的图变成一个二分图。这个要被删除的边集，叫做奇回路覆盖。剩下的边就全部可以成为割边了。所以，平面图的最大割大小 = 总边数 - 最小奇回路覆盖的边数。

现在，关键问题变成了如何找到最小的奇回路覆盖。这里，对偶图的概念登场了。平面图G的每个面对应对偶图G中的一个顶点，如果G中两个面共享一条边，那么在G中对应的两个顶点之间就有一条边。一个精妙的观察是：G中的奇面对应G中的奇度数顶点！在G中删除一条边以合并两个面，相当于在G中删除这条边对应的边（注意对偶图可能是多重边）。我们的目标是把G*中所有奇度数顶点变成偶度数，而手段是删除边。这难道不熟悉吗？这几乎就是中国邮递员问题的“镜像”版本！邮递员问题是通过复制边来增加度数使奇变偶，而这里是通过删除边来减少度数使奇变偶（因为删除一条边会使它连接的两个顶点的度数各减1）。虽然操作相反，但数学结构完全同构。

因此，算法步骤也高度对应：1. 构建平面图G的对偶图G*。2. 找出G中所有奇度数顶点。3. 计算这些奇顶点两两之间在G中的最短路径长度（边数）。4. 在这些奇顶点构成的完全图上，求最小权完美匹配。5. 对于匹配中的每一对顶点，在G*中删除它们最短路径上的边（等价于在G中删除对应边）。这些被删除的边就构成了最小奇回路覆盖。剩下的G的子图是二分图，其边数就是最大割的大小。

4. 最大割算法实战：从对偶图构建到匹配求解

理论联系实际，我们动手过一遍。假设我们有一个平面图的嵌入（即每个顶点都有平面坐标，每条边知道它左侧和右侧是哪个面）。构建对偶图是第一步，也是实现中最需要细心的地方。

4.1 构建对偶图

对于给定的平面嵌入，我们可以通过遍历边来构建对偶图。每条边连接两个面（外部无限面也算一个面）。我们可以用一个数据结构记录每个面包含的边，然后建立面与面之间的邻接关系。

def build_dual_graph(vertices, edges, faces):
    """
    根据平面嵌入构建对偶图。
    vertices: 顶点列表，每个顶点有坐标(x, y)。
    edges: 边列表，每条边是(u, v)，并知道其左侧面left_face和右侧面right_face。
    faces: 面列表，每个面有一个id。
    返回对偶图的邻接表表示。
    """
    num_faces = len(faces)
    dual_adj = [[] for _ in range(num_faces)]
    # 假设外部无限面的id为0
    for edge in edges:
        f_left = edge.left_face
        f_right = edge.right_face
        # 在对偶图中，两个面之间有一条边
        dual_adj[f_left].append(f_right)
        dual_adj[f_right].append(f_left)
    # 注意：由于共享多条边，对偶图可能包含重边，这里邻接表直接记录，后续计算最短路时重边权重为1。
    return dual_adj

4.2 识别奇面与求解匹配

构建好对偶图G*后，我们计算每个面的度数（即对偶图顶点的度数），找出奇度数的面。

def find_odd_faces(dual_adj):
    """找出对偶图中度数为奇数的顶点（对应原图的奇面）。"""
    odd_face_indices = []
    for i, neighbors in enumerate(dual_adj):
        if len(neighbors) % 2 == 1:
            odd_face_indices.append(i)
    return odd_face_indices

接下来，我们需要计算这些奇面对应顶点在G中的两两最短路径长度。因为G的边没有权重（或者权重为1），所以这等价于求它们之间的最短跳数。可以用BFS来求。

from collections import deque

def bfs_shortest_paths(dual_adj, start):
    """从start顶点出发，BFS求到所有顶点的最短距离（无权图）。"""
    n = len(dual_adj)
    dist = [-1] * n
    dist[start] = 0
    q = deque([start])
    while q:
        u = q.popleft()
        for v in dual_adj[u]:
            if dist[v] == -1:
                dist[v] = dist[u] + 1
                q.append(v)
    return dist

def compute_odd_face_distances(dual_adj, odd_face_indices):
    """计算奇面两两之间的最短距离。"""
    k = len(odd_face_indices)
    # 距离矩阵
    dist_matrix = [[0]*k for _ in range(k)]
    # 对每个奇面作为源点做BFS
    for idx_i, face_i in enumerate(odd_face_indices):
        distances = bfs_shortest_paths(dual_adj, face_i)
        for idx_j, face_j in enumerate(odd_face_indices):
            dist_matrix[idx_i][idx_j] = distances[face_j]
    return dist_matrix

有了距离矩阵，问题又回到了熟悉的最小权完美匹配。我们可以复用之前为中国邮递员问题写的匹配求解器（DP或库函数）。求解出匹配对后，每一对匹配的奇面，我们就需要在G中删除它们最短路径上的边。在实际操作中，我们并不需要真的修改G的图结构，只需要记录下需要从原图G中删除的边。在G*中，两个面之间的最短路径对应原图G中的一系列相邻的面。删除这条路径上的边，意味着在原图G中删除这些边。最终，从原图G的总边数中减去删除的边数，就得到了最大割的大小。

4.3 一个完整的例子与调试心得

我记得在第一次实现这个算法时，被一个边界情况卡了很久：外部无限面的处理。在平面图中，最外面的区域也是一个面。在构建对偶图时，必须给它分配一个顶点。它的度数可能很大，也可能是奇数。在计算奇面时，必须把它包括在内。在BFS计算最短路径时，它和其他面一视同仁。这个点没处理好，匹配结果就会出错，导致求出的“最大割”边数比实际大。

另一个调试重点是最短路径的重构。为了知道要删除原图的哪些边，我们需要知道G中奇面之间最短路径具体经过哪些边。这需要在BFS时记录前驱信息。当匹配确定后，对于每一对匹配的奇面，我们要回溯找出连接它们的最短路径在G中经过的边，然后映射回原图G的边。这个映射关系需要在构建对偶图时就建立好，记录每条对偶图边对应原图的哪条边。

最后，验证结果的一个好方法是：删除你计算出的边集后，检查剩下的图是否为二分图（可以用染色法验证）。同时，可以尝试一些小型平面图，比如网格图，其最大割大小是已知的，可以用来验证算法的正确性。

5. 算法思想的延伸与总结

走完了中国邮递员问题和平面图最大割问题的完整算法旅程，不知道你有没有感受到那种“大道至简”的美感。两个看似迥异的问题，最终都归结为同一个核心步骤：识别奇偶性有问题的对象（奇度数顶点/奇面） -> 计算它们之间的“距离” -> 进行最小权完美匹配。这种“奇偶配对”的思想，在图论和组合优化中其实是一个非常有力的工具。

这种转化之所以能成功，关键在于问题本身具有的对偶性和数学结构。在中国邮递员问题中，是图本身的顶点度数奇偶性；在平面图最大割中，是其对偶图顶点度数奇偶性。一旦我们发现了这种结构，就能将看似全局的、复杂的问题，分解为可计算的、局部的匹配问题。

从工程实践的角度看，实现这两个算法给我们带来的启示是：不要被问题的原始形式吓倒。很多NP难的问题，在特定的限制条件下（如图是平面的、度数有特点等）会变得可解。而求解的关键，往往在于找到那个正确的“转化”视角。同时，在实现时，要善于利用现成的成熟算法模块（如最短路、匹配），并针对具体场景做优化（如用Dijkstra代替Floyd，用DP求解小规模匹配）。

在我自己的项目中，我曾将中国邮递员问题的思想用于网络路由的冗余路径规划，也借鉴过平面图最大割中的对偶思想来分析某些电路板布线问题。经典算法的价值，不仅在于解决它原本定义的问题，更在于其思想能照亮其他看似黑暗的角落。

最后，如果你对这两个问题感兴趣，我建议可以动手实现一遍，用不同的图进行测试。从简单的例子开始，比如一个“日”字形的路网，或者一个正方形的网格图。亲自调试代码、验证结果的过程，会让你对算法的理解深入骨髓。遇到bug时，回头再看看奇偶配对的原理，往往就能找到突破口。算法学习，终究是一场需要亲手实践的旅程。