doocs/leetcode 图论算法实战：从基础到高级的全面解析
项目地址: https://gitcode.com/doocs/leetcode 开篇痛点：为什么图论算法如此重要？
还在为LeetCode中的图论题目头疼吗？面对复杂的图结构、最短路径、拓扑排序等问题时感到无从下手？本文将带你系统掌握doocs/leetcode项目中图论算法的精髓，一文解决所有图论难题！
读完本文你将获得：
- ✅ 图论基础概念与核心算法原理
- ✅ 常见图论题型的分类与解题模板
- ✅ 多种编程语言的实现代码示例
- ✅ 实战案例分析与优化技巧
- ✅ 面试高频图论题目的深度解析
图论算法核心知识体系
1. 图的基本概念与表示
图（Graph）是由顶点（Vertex）和边（Edge）组成的数据结构，广泛应用于网络分析、社交网络、路径规划等领域。
2. 图的遍历算法
2.1 BFS（广度优先搜索）
BFS适用于寻找最短路径、层次遍历等场景：
def bfs(graph, start):
visited = set()
queue = deque([start])
visited.add(start)
while queue:
node = queue.popleft()
# 处理当前节点
for neighbor in graph[node]:
if neighbor not in visited:
visited.add(neighbor)
queue.append(neighbor)
2.2 DFS（深度优先搜索）
DFS适用于路径查找、拓扑排序、连通分量等场景：
def dfs(graph, node, visited):
visited.add(node)
# 处理当前节点
for neighbor in graph[node]:
if neighbor not in visited:
dfs(graph, neighbor, visited)
3. 最短路径算法实战
3.1 Dijkstra算法（743. 网络延迟时间）
Dijkstra算法解决单源最短路径问题，适用于非负权图：
class Solution:
def networkDelayTime(self, times: List[List[int]], n: int, k: int) -> int:
# 构建邻接表
graph = [[] for _ in range(n)]
for u, v, w in times:
graph[u-1].append((v-1, w))
# 初始化距离数组
dist = [float('inf')] * n
dist[k-1] = 0
# 优先队列优化
heap = [(0, k-1)]
while heap:
d, node = heapq.heappop(heap)
if d > dist[node]:
continue
for neighbor, weight in graph[node]:
new_dist = d + weight
if new_dist < dist[neighbor]:
dist[neighbor] = new_dist
heapq.heappush(heap, (new_dist, neighbor))
max_dist = max(dist)
return max_dist if max_dist < float('inf') else -1
算法复杂度分析：
- 时间复杂度：O(E log V)，使用优先队列优化
- 空间复杂度：O(V + E)
3.2 Bellman-Ford算法
适用于包含负权边的最短路径问题：
def bellman_ford(graph, n, start):
dist = [float('inf')] * n
dist[start] = 0
# 松弛操作
for _ in range(n-1):
for u, v, w in graph:
if dist[u] + w < dist[v]:
dist[v] = dist[u] + w
# 检测负权环
for u, v, w in graph:
if dist[u] + w < dist[v]:
return None # 存在负权环
return dist
4. 拓扑排序与应用
拓扑排序用于有向无环图（DAG）的节点线性排序：
def topological_sort(graph, n):
# 计算入度
in_degree = [0] * n
for i in range(n):
for j in graph[i]:
in_degree[j] += 1
# 初始化队列
queue = deque()
for i in range(n):
if in_degree[i] == 0:
queue.append(i)
result = []
while queue:
node = queue.popleft()
result.append(node)
for neighbor in graph[node]:
in_degree[neighbor] -= 1
if in_degree[neighbor] == 0:
queue.append(neighbor)
return result if len(result) == n else [] # 判断是否有环
5. 并查集与连通性
并查集（Union-Find）用于高效处理连通性问题：
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
6. 二分图判定（785. 判断二分图）
染色法判断图是否为二分图：
class Solution:
def isBipartite(self, graph: List[List[int]]) -> bool:
n = len(graph)
color = [0] * n # 0:未染色, 1:红色, -1:蓝色
def dfs(node, c):
color[node] = c
for neighbor in graph[node]:
if color[neighbor] == c:
return False
if color[neighbor] == 0 and not dfs(neighbor, -c):
return False
return True
for i in range(n):
if color[i] == 0 and not dfs(i, 1):
return False
return True
7. 常见图论题型分类与解题策略
| 题型分类 | 典型题目 | 核心算法 | 难度 |
|---|---|---|---|
| 最短路径 | 743, 1091, 1293 | Dijkstra, BFS | 中等 |
| 拓扑排序 | 207, 210 | Kahn算法 | 中等 |
| 连通性 | 547, 684 | 并查集, DFS | 中等 |
| 二分图 | 785, 886 | 染色法 | 中等 |
| 最小生成树 | 1584 | Prim, Kruskal | 困难 |
| 欧拉路径 | 332 | Hierholzer算法 | 困难 |
8. 实战案例分析：网络延迟时间（743）
问题分析： 给定有向加权图，求从源点k到所有其他节点的最短路径的最大值。
解题步骤：
- 构建图的邻接表表示
- 使用Dijkstra算法计算单源最短路径
- 找出所有最短路径中的最大值
- 处理不可达节点的情况
优化技巧：
- 使用优先队列代替普通队列
- 提前终止不必要的计算
- 合理选择数据结构
9. 多语言实现对比
Java实现Dijkstra算法：
class Solution {
public int networkDelayTime(int[][] times, int n, int k) {
final int INF = 1 << 29;
List<int[]>[] graph = new ArrayList[n];
Arrays.setAll(graph, i -> new ArrayList<>());
for (int[] time : times) {
graph[time[0]-1].add(new int[]{time[1]-1, time[2]});
}
int[] dist = new int[n];
Arrays.fill(dist, INF);
dist[k-1] = 0;
PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[0] - b[0]);
pq.offer(new int[]{0, k-1});
while (!pq.isEmpty()) {
int[] curr = pq.poll();
int d = curr[0], u = curr[1];
if (d > dist[u]) continue;
for (int[] edge : graph[u]) {
int v = edge[0], w = edge[1];
if (dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
pq.offer(new int[]{dist[v], v});
}
}
}
int ans = Arrays.stream(dist).max().getAsInt();
return ans == INF ? -1 : ans;
}
}
C++实现：
class Solution {
public:
int networkDelayTime(vector<vector<int>>& times, int n, int k) {
const int INF = 1e9;
vector<vector<pair<int, int>>> graph(n);
for (auto& time : times) {
graph[time[0]-1].emplace_back(time[1]-1, time[2]);
}
vector<int> dist(n, INF);
dist[k-1] = 0;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> pq;
pq.emplace(0, k-1);
while (!pq.empty()) {
auto [d, u] = pq.top();
pq.pop();
if (d > dist[u]) continue;
for (auto [v, w] : graph[u]) {
if (dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
pq.emplace(dist[v], v);
}
}
}
int ans = *max_element(dist.begin(), dist.end());
return ans == INF ? -1 : ans;
}
};
10. 面试准备与技巧
常见面试问题：
- 解释Dijkstra和Bellman-Ford的区别
- 什么时候使用BFS而不是DFS？
- 如何检测图中是否存在环？
- 解释并查集的路径压缩优化
解题模板总结：
# 图论问题通用解题框架
def solve_graph_problem(graph, n, start):
# 1. 初始化数据结构
visited = set()
distance = [float('inf')] * n
distance[start] = 0
# 2. 选择遍历策略（BFS/DFS/Dijkstra）
queue = deque([start])
visited.add(start)
# 3. 遍历处理
while queue:
current = queue.popleft()
for neighbor in graph[current]:
# 4. 根据具体问题更新状态
new_dist = distance[current] + weight
if new_dist < distance[neighbor]:
distance[neighbor] = new_dist
queue.append(neighbor)
# 5. 返回结果
return max(distance) if max(distance) < float('inf') else -1
11. 性能优化与注意事项
内存优化：
- 使用邻接表代替邻接矩阵稀疏图
- 合理选择数据结构（优先队列 vs 普通队列）
- 避免不必要的拷贝操作
时间优化：
- 使用合适的算法复杂度
- 提前终止不必要的计算
- 利用缓存和记忆化
常见陷阱：
- 忘记处理自环和平行边
- 未考虑图的连通性
- 权重为负时的算法选择错误
总结与展望
通过本文的系统学习，你已经掌握了doocs/leetcode项目中图论算法的核心知识和实战技巧。图论作为算法竞赛和面试中的重要组成部分，需要不断练习和总结。
下一步学习建议：
- 完成LeetCode图论标签下的所有题目
- 尝试使用不同编程语言实现相同算法
- 学习高级图论算法如最大流、最小割等
- 参与开源项目，阅读优秀的图论实现代码
记住，算法学习是一个循序渐进的过程，坚持练习和思考，你一定能够攻克所有图论难题！
温馨提示： 如果本文对你有帮助，请点赞收藏支持！欢迎关注更多算法解析文章。
创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考
