图论算法精讲：最短路径与LeetCode实战解析

1. 项目概述

今天要分享的是我在算法学习过程中整理的图论专题笔记，主要包含三个核心内容：LeetCode第97题"小明逛公园"的解题思路、第127题"骑士的攻击"的解法，以及最短路算法和图论知识的系统总结。这些题目和知识点都是算法竞赛和面试中的常客，掌握它们对提升编程能力至关重要。

作为一名算法工程师，我发现在实际工作中，图论算法的应用场景非常广泛。从社交网络的关系分析，到物流配送的路径规划，再到游戏中的AI寻路，图论都发挥着关键作用。这次整理的笔记不仅记录了标准解法，还包含了我自己在刷题过程中总结的优化技巧和易错点。

2. 核心算法解析

2.1 最短路算法精要

最短路算法是图论中的基础算法，主要有以下三种经典实现：

1. Dijkstra算法：

   • 适用条件：无负权边的图
   • 时间复杂度：O((V+E)logV)（使用优先队列）
   • 核心思想：贪心策略，每次选择当前距离起点最近的节点进行松弛操作
   • 实现要点：

     python复制import heapq
     def dijkstra(graph, start):
         distances = {node: float('inf') for node in graph}
         distances[start] = 0
         heap = [(0, start)]
         
         while heap:
             current_dist, current_node = heapq.heappop(heap)
             if current_dist > distances[current_node]:
                 continue
             
             for neighbor, weight in graph[current_node].items():
                 distance = current_dist + weight
                 if distance < distances[neighbor]:
                     distances[neighbor] = distance
                     heapq.heappush(heap, (distance, neighbor))
         return distances
     

2. Bellman-Ford算法：

   • 适用条件：可以处理负权边，能检测负权环
   • 时间复杂度：O(VE)
   • 核心思想：对所有边进行V-1次松弛操作

3. Floyd-Warshall算法：

   • 适用条件：计算所有节点对的最短路径
   • 时间复杂度：O(V³)
   • 核心思想：动态规划，逐步考虑中间节点

提示：Dijkstra算法在稠密图中性能较好，而稀疏图可以考虑使用SPFA（Shortest Path Faster Algorithm）优化版本。

2.2 图论常见问题分类

根据我的刷题经验，图论问题大致可以分为以下几类：

3. 题目详解与实战

3.1 LeetCode 97 - 小明逛公园

这是一道典型的最短路径变形题，题目描述为：公园有N个景点，M条道路，小明想从入口到出口，并经过至少K个景点，求最短路径。

解题思路：

1. 将问题转化为状态空间搜索，状态表示为（当前节点，已游览景点数）
2. 使用优先队列进行Dijkstra算法的变形
3. 当到达终点且游览景点数≥K时，返回当前路径长度

优化技巧：

• 使用位运算压缩状态（如果景点数≤32）
• 提前终止条件：当前路径长度已超过已知最优解

python复制def shortestPath(graph, start, end, K):
    heap = [(0, start, 0)]
    visited = {}
    min_dist = float('inf')
    
    while heap:
        dist, node, count = heapq.heappop(heap)
        if node == end and count >= K:
            return dist
        if (node, count) in visited and visited[(node, count)] <= dist:
            continue
        visited[(node, count)] = dist
        
        for neighbor, weight in graph[node].items():
            new_dist = dist + weight
            new_count = count + 1
            if new_dist < min_dist:
                heapq.heappush(heap, (new_dist, neighbor, new_count))
    
    return -1

3.2 LeetCode 127 - 骑士的攻击

这道题考察的是棋盘上的BFS应用，计算骑士在无限棋盘上能够到达的格子数。

关键点：

1. 骑士的移动方式有8种可能：(±1,±2)和(±2,±1)
2. 使用BFS进行层级遍历，记录访问过的位置
3. 需要考虑对称性优化，减少计算量

实现细节：

python复制def knightAttack(n, x, y):
    directions = [(1,2),(2,1),(-1,2),(-2,1),
                 (1,-2),(2,-1),(-1,-2),(-2,-1)]
    visited = set()
    queue = deque()
    queue.append((x, y, 0))
    visited.add((x, y))
    count = 0
    
    while queue:
        cx, cy, steps = queue.popleft()
        if steps == n:
            continue
        for dx, dy in directions:
            nx, ny = cx + dx, cy + dy
            if (nx, ny) not in visited:
                visited.add((nx, ny))
                count += 1
                queue.append((nx, ny, steps + 1))
    return count

4. 算法优化与性能对比

4.1 最短路算法性能实测

我在不同规模的图上测试了三种最短路算法的性能：

从测试结果可以看出：

1. 小规模图（<1000节点）：三种算法都可使用，Dijkstra最优
2. 中等规模图：Dijkstra仍然表现良好
3. 大规模图：需要考虑更高效的优化算法或分布式计算

4.2 常见错误与调试技巧

在实现图论算法时，我遇到过以下典型问题：

1. 优先队列使用错误：

   • 错误：忘记处理重复节点
   • 修正：在取出节点时检查是否已有更优解

2. 负权边处理不当：

   • 错误：在存在负权边时使用Dijkstra
   • 修正：改用Bellman-Ford或SPFA

3. 状态表示不完整：

   • 错误：在需要记录额外状态（如访问次数）时遗漏
   • 修正：仔细分析问题需求，设计完整的状态表示

4. 边界条件遗漏：

   • 错误：未处理空图或单节点情况
   • 修正：添加特殊情况的检查

5. 图论知识体系构建建议

根据我的学习经验，系统掌握图论需要以下几个步骤：

1. 基础数据结构：

   • 熟练掌握图的邻接表和邻接矩阵表示
   • 理解不同表示法的适用场景和性能特点

2. 核心算法模板：

   • 熟记DFS/BFS的标准实现
   • 准备Dijkstra、Prim等算法的模板代码

3. 问题转化能力：

   • 训练将实际问题抽象为图论模型的能力
   • 例如：把任务调度看作拓扑排序问题

4. 优化技巧：

   • 学习双向BFS、A*等优化方法
   • 掌握状态压缩等高级技巧

我在学习过程中发现，定期整理笔记和重做经典题目非常有效。建议每学完一个算法，就找3-5道相关题目练习，并记录解题思路和优化过程。