图论中的最小生成树算法详解：Prim与Kruskal实现
项目地址: https://gitcode.com/gh_mirrors/le/LeetCode-Py 引言：为什么需要最小生成树？
在现实世界中，我们经常需要将多个点以最小的成本连接起来。比如：
- 城市规划：用最少的电缆连接所有小区
- 交通网络：建设连接所有城市的最低成本公路系统
- 通信网络：构建覆盖所有基站的最经济光纤网络
这些问题都可以抽象为**最小生成树（Minimum Spanning Tree，MST）**问题。本文将深入探讨两种经典的最小生成树算法：Prim算法和Kruskal算法，并通过实际代码示例帮助你彻底掌握。
1. 图论基础概念
1.1 什么是生成树？
**生成树（Spanning Tree）**是原图G的一个子图，具有以下特征：
| 特性 | 描述 | 数学表达 |
|---|---|---|
| 顶点完整性 | 包含原图所有顶点 | $V_{MST} = V_G$ |
| 连通性 | 任意两顶点间存在路径 | 连通子图 |
| 无环性 | 不包含任何环路 | 树结构 |
| 最小边数 | 边数为顶点数减1 | $E = V - 1$ |
1.2 最小生成树的定义
**最小生成树（Minimum Spanning Tree）**是在所有可能的生成树中，边的权重之和最小的那棵树。
2. Prim算法：从顶点出发的贪心策略
2.1 算法思想与原理
Prim算法采用贪心策略，从一个起始顶点开始，逐步扩展最小生成树。其核心思想是：每次选择与当前生成树连接的最短边。
2.2 算法步骤详解
-
初始化阶段
- 创建距离数组
dist，初始化为无穷大 - 创建访问标记集合
vis - 设置起始顶点距离为0
- 创建距离数组
-
主循环阶段（执行V-1次）
- 在未访问顶点中找到距离最小的顶点
- 将该顶点加入最小生成树
- 更新相邻顶点的距离
-
终止条件
- 当所有顶点都加入生成树时结束
2.3 代码实现与解析
class PrimMST:
def prim(self, graph, start):
"""
Prim算法实现最小生成树
:param graph: 邻接矩阵表示的图
:param start: 起始顶点索引
:return: 最小生成树的总权重
"""
size = len(graph)
vis = set() # 已访问顶点集合
dist = [float('inf')] * size # 到MST的最小距离
total_weight = 0 # 最小生成树总权重
dist[start] = 0 # 起始顶点到自身的距离为0
# 初始化起始顶点到其他顶点的距离
for i in range(size):
if i != start:
dist[i] = graph[start][i]
vis.add(start)
# 构建最小生成树
for _ in range(size - 1):
min_dist = float('inf')
min_index = -1
# 找到距离最小的未访问顶点
for i in range(size):
if i not in vis and dist[i] < min_dist:
min_dist = dist[i]
min_index = i
if min_index == -1: # 图不连通
return -1
total_weight += min_dist
vis.add(min_index)
# 更新相邻顶点的距离
for i in range(size):
if (i not in vis and
graph[min_index][i] < dist[i]):
dist[i] = graph[min_index][i]
return total_weight
2.4 复杂度分析与优化
| 操作 | 时间复杂度 | 空间复杂度 |
|---|---|---|
| 初始化 | $O(V)$ | $O(V)$ |
| 寻找最小距离顶点 | $O(V^2)$ | - |
| 更新距离 | $O(V^2)$ | - |
| 总计 | $O(V^2)$ | $O(V)$ |
优化方案：使用优先队列（最小堆）可以将时间复杂度优化到 $O(E + V \log V)$。
3. Kruskal算法：基于边排序的并查集应用
3.1 算法思想与原理
Kruskal算法采用不同的策略：按边权重从小到大排序，逐步添加不会形成环路的边。
3.2 并查集数据结构
并查集（Union-Find）是Kruskal算法的核心数据结构，用于高效管理顶点的连通性。
class UnionFind:
"""并查集实现"""
def __init__(self, n):
self.parent = list(range(n)) # 父节点数组
self.rank = [0] * n # 秩（用于优化）
def find(self, x):
"""查找根节点（路径压缩）"""
if self.parent[x] != x:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def union(self, x, y):
"""合并两个集合（按秩合并）"""
root_x = self.find(x)
root_y = self.find(y)
if root_x == root_y:
return False # 已经在同一集合
# 按秩合并优化
if self.rank[root_x] < self.rank[root_y]:
self.parent[root_x] = root_y
elif self.rank[root_x] > self.rank[root_y]:
self.parent[root_y] = root_x
else:
self.parent[root_y] = root_x
self.rank[root_x] += 1
return True
3.3 Kruskal算法实现
class KruskalMST:
def kruskal(self, edges, vertex_count):
"""
Kruskal算法实现最小生成树
:param edges: 边列表，格式为[(u, v, weight)]
:param vertex_count: 顶点数量
:return: 最小生成树的总权重
"""
# 按边权重排序
edges.sort(key=lambda x: x[2])
uf = UnionFind(vertex_count)
total_weight = 0
edges_selected = 0
for u, v, weight in edges:
if edges_selected == vertex_count - 1:
break
if uf.union(u, v):
total_weight += weight
edges_selected += 1
return total_weight
3.4 复杂度分析
| 操作 | 时间复杂度 | 说明 |
|---|---|---|
| 边排序 | $O(E \log E)$ | 快速排序 |
| 并查集操作 | $O(E \cdot \alpha(V))$ | 近似线性 |
| 总计 | $O(E \log E)$ | 主导因素是排序 |
其中 $\alpha$ 是阿克曼函数的反函数，增长极其缓慢。
4. 算法对比与选择指南
4.1 Prim vs Kruskal 全面对比
| 特性 | Prim算法 | Kruskal算法 |
|---|---|---|
| 算法思想 | 顶点扩展 | 边选择 |
| 数据结构 | 距离数组 | 并查集 |
| 时间复杂度 | $O(V^2)$ 或 $O(E + V \log V)$ | $O(E \log E)$ |
| 空间复杂度 | $O(V)$ | $O(V + E)$ |
| 适用场景 | 稠密图 | 稀疏图 |
| 实现难度 | 中等 | 中等（需要并查集） |
| 是否需要排序 | 否 | 是 |
4.2 选择建议
5. 实战应用：LeetCode 1584题解
5.1 问题描述
给定平面上的一些点，计算连接所有点的最小费用（曼哈顿距离）。
5.2 Prim算法解决方案
class Solution:
def minCostConnectPoints(self, points: List[List[int]]) -> int:
n = len(points)
if n <= 1:
return 0
# 计算曼哈顿距离
def manhattan(i, j):
return abs(points[i][0] - points[j][0]) + abs(points[i][1] - points[j][1])
# Prim算法
visited = [False] * n
min_dist = [float('inf')] * n
min_dist[0] = 0
total_cost = 0
for _ in range(n):
# 找到当前距离最小的未访问顶点
u = -1
for i in range(n):
if not visited[i] and (u == -1 or min_dist[i] < min_dist[u]):
u = i
visited[u] = True
total_cost += min_dist[u]
# 更新相邻顶点的最小距离
for v in range(n):
if not visited[v]:
dist = manhattan(u, v)
if dist < min_dist[v]:
min_dist[v] = dist
return total_cost
5.3 Kruskal算法解决方案
class UnionFind:
def __init__(self, n):
self.parent = list(range(n))
self.rank = [0] * n
def find(self, x):
if self.parent[x] != x:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def union(self, x, y):
rx, ry = self.find(x), self.find(y)
if rx == ry:
return False
if self.rank[rx] < self.rank[ry]:
self.parent[rx] = ry
elif self.rank[rx] > self.rank[ry]:
self.parent[ry] = rx
else:
self.parent[ry] = rx
self.rank[rx] += 1
return True
class Solution:
def minCostConnectPoints(self, points: List[List[int]]) -> int:
n = len(points)
edges = []
# 生成所有边
for i in range(n):
for j in range(i + 1, n):
dist = abs(points[i][0] - points[j][0]) + abs(points[i][1] - points[j][1])
edges.append((dist, i, j))
# 按距离排序
edges.sort()
uf = UnionFind(n)
total_cost = 0
edges_used = 0
for dist, i, j in edges:
if edges_used == n - 1:
break
if uf.union(i, j):
total_cost += dist
edges_used += 1
return total_cost
6. 性能优化技巧
6.1 Prim算法优化
使用优先队列（最小堆）优化：
import heapq
def prim_optimized(graph, start):
n = len(graph)
visited = [False] * n
heap = [(0, start)] # (distance, vertex)
total_weight = 0
while heap and len(visited) < n:
dist, u = heapq.heappop(heap)
if not visited[u]:
visited[u] = True
total_weight += dist
for v, weight in enumerate(graph[u]):
if not visited[v] and weight < float('inf'):
heapq.heappush(heap, (weight, v))
return total_weight
6.2 Kruskal算法优化
使用路径压缩和按秩合并的并查集：
class OptimizedUnionFind:
def __init__(self, n):
self.parent = list(range(n))
self.rank = [0] * n
def find(self, x):
# 路径压缩
if self.parent[x] != x:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def union(self, x, y):
# 按秩合并
root_x = self.find(x)
root_y = self.find(y)
if root_x == root_y:
return False
if self.rank[root_x] < self.rank[root_y]:
self.parent[root_x] = root_y
elif self.rank[root_x] > self.rank[root_y]:
self.parent[root_y] = root_x
else:
self.parent[root_y] = root_x
self.rank[root_x] += 1
return True
7. 常见问题与解决方案
7.1 如何处理不连通图？
7.2 边权重相等时的处理
当多条边权重相等时，两种算法都能正确工作，但可能产生不同的MST（最小生成树不唯一）。
7.3 大规模图的处理
对于超大规模图（顶点数 > 10^6），可以考虑：
- 使用外部排序处理边
- 分布式计算框架
- 近似算法
总结
最小生成树算法是图论中的基础且重要的算法，Prim和Kruskal算法各有其适用场景：
- Prim算法更适合稠密图，实现相对简单
- Kruskal算法更适合稀疏图，需要并查集支持
掌握这两种算法不仅有助于解决LeetCode等编程题目，更重要的是培养了解决实际优化问题的思维能力。建议读者通过实际编码练习来加深理解，并尝试解决更多相关的图论问题。
进一步学习建议：
- 实现两种算法的优化版本
- 解决更多MST相关题目
- 学习其他图算法（最短路径、网络流等）
- 了解实际应用场景中的变种问题
通过系统学习和实践，你将能够熟练运用最小生成树算法解决各类连通性优化问题。
创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考
