引言
在图论中，最短路径问题是一个经典且广泛应用的问题。特别是在**无权图（Unweighted Graph）**中，即图的边没有权重或所有边的权重相同（通常为1），最短路径的计算可以通过特殊的高效算法来完成。本文将介绍无权图的最短路径计算的基本思想和常用算法，包括它们的特点、适用场景以及优缺点。
1. 无权图的最短路径问题
1.1 什么是无权图？
无权图是指边没有权重（或权重均为1）的图。在这种图中，路径的长度仅取决于路径上边的数量，而与其他属性无关。因此，求解无权图的最短路径问题，等价于计算从起点到终点所需经过的最少边数。
例如，假设有如下无权图：
A -- B -- C
| |
D -- E -- F
从 A 到 F 的最短路径是 A -> D -> E -> F，路径长度为3（即3条边）。
1.2. 常见应用场景
无权图的最短路径计算在以下场景中有广泛应用：
- 迷宫求解：从入口到出口的最短路径。
- 社交网络分析：计算人与人之间的最短连接。
- 计算机网络：数据包在无权网络中的最短传输路径。
- 游戏开发中的寻路：角色在规则网格地图上的最短路径。
2. 无权图中最短路径的常用算法
由于无权图的特殊性（边权重为1），许多加权图使用的算法（如 Dijkstra 算法）在无权图中可以被更高效的算法替代。以下是三种常用的无权图最短路径计算算法：
2.1 广度优先搜索（BFS）
原理
广度优先搜索是一种逐层扩展节点的搜索方式，适合处理无权图的最短路径问题。由于 BFS 是逐层扩展的，第一次到达目标节点时，路径一定是最短的。
算法步骤
- 使用队列维护当前待访问的节点。
- 从起点开始，将起点加入队列并标记为已访问。
- 依次访问队列中的节点，扩展它的邻居节点。
- 如果扩展到终点，停止搜索，返回路径长度。
代码示例：
def bfs_shortest_path(graph, start, end):
queue = deque([(start, [start])]) # 队列存储 (当前节点, 当前路径)
visited = set() # 记录访问过的节点
while queue:
current, path = queue.popleft()
if current == end:
return path # 找到终点，返回完整路径
visited.add(current)
for neighbor in graph[current]: # 遍历当前节点的邻居
if neighbor not in visited:
visited.add(neighbor) # 标记访问，避免重复入队
queue.append((neighbor, path + [neighbor]))
return [] # 如果无法到达终点，返回空路径
时间复杂度
- 时间复杂度：O(V + E)，其中 V 为节点数，E 为边数。
- 空间复杂度：O(V)，需要存储节点的访问状态。
优缺点
- 优点：简单高效，能够保证找到无权图的最短路径。
- 缺点：只能用于无权图；对于稠密图，可能需要较大的内存。
适用场景
- 无权图中最短路径的首选算法，适用于迷宫求解、规则网格地图等。
2.2 A*搜索算法
原理
A算法是一种启发式搜索算法，通过结合实际代价（从起点到当前节点的距离）和启发式代价（当前节点到终点的估计距离）来引导搜索方向。在无权图中，A算法可以通过适当的启发式函数（如曼哈顿距离、欧几里得距离或切比雪夫距离）有效减少搜索的节点数。
算法步骤
- 初始化优先队列，将起点加入队列。
- 优先扩展估计代价最小的节点。
- 对每个扩展的节点，更新其邻居节点的代价值。
- 如果到达终点，停止搜索，返回路径。
代码示例：
import heapq
def heuristic(a, b):
# 使用曼哈顿距离作为启发式函数
return abs(a[0] - b[0]) + abs(a[1] - b[1])
def astar_shortest_path(grid, start, end):
rows, cols = len(grid), len(grid[0])
open_set = []
heapq.heappush(open_set, (0, start)) # 优先队列 (f值, 节点)
came_from = {}
g_score = {start: 0} # 从起点到每个节点的实际代价
f_score = {start: heuristic(start, end)} # 估计总代价
while open_set:
_, current = heapq.heappop(open_set)
if current == end: # 找到终点
path = []
while current in came_from: # 回溯路径
path.append(current)
current = came_from[current]
return path[::-1] # 返回完整路径
x, y = current
for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: # 四个方向
neighbor = (x + dx, y + dy)
if 0 <= neighbor[0] < rows and 0 <= neighbor[1] < cols and grid[neighbor[0]][neighbor[1]] == 0:
tentative_g_score = g_score[current] + 1
if neighbor not in g_score or tentative_g_score < g_score[neighbor]:
came_from[neighbor] = current
g_score[neighbor] = tentative_g_score
f_score[neighbor] = tentative_g_score + heuristic(neighbor, end)
heapq.heappush(open_set, (f_score[neighbor], neighbor))
return [] # 如果无法到达终点，返回空路径
时间复杂度
- 时间复杂度：O(V + E)，但实际效率取决于启发式函数的质量。
- 空间复杂度：O(V)。
优缺点
- 优点：通过启发式函数减少了搜索的节点数。
- 缺点：需要设计合适的启发式函数，计算量相对 BFS 较大。
适用场景
规则网格地图上的最短路径计算，尤其是对性能有要求的场景。
2.3 跳点搜索（Jump Point Search, JPS）
原理
跳点搜索（Jump Point Search, JPS）是对 A* 算法的优化，专注于规则网格地图。其核心思想是通过“跳跃”跳过冗余节点，只扩展关键节点（如拐点或障碍附近的节点）。
核心步骤
- 从当前节点沿某个方向跳跃，直到遇到以下情况之一：
- 遇到目标节点。
- 遇到障碍物。
- 遇到关键节点（跳点）。
- 对关键节点进行递归搜索，继续跳跃扩展。
- 使用启发式函数（如曼哈顿距离）指导搜索方向。
代码示例：
import heapq
class JumpPointSearch:
def __init__(self, grid, start, end):
self.grid = grid # 二值化地图，0 表示可通行，1 表示障碍
self.start = start
self.end = end
self.rows = len(grid)
self.cols = len(grid[0])
self.open_set = []
self.g_score = {start: 0}
self.f_score = {start: self.heuristic(start, end)}
self.came_from = {}
def heuristic(self, a, b):
"""使用曼哈顿距离作为启发式函数"""
return abs(a[0] - b[0]) + abs(a[1] - b[1])
def is_valid(self, x, y):
"""检查节点是否在合法范围内且可通行"""
return 0 <= x < self.rows and 0 <= y < self.cols and self.grid[x][y] == 0
def jump(self, x, y, dx, dy):
"""
跳点搜索：从当前节点 (x, y) 沿方向 (dx, dy) 跳跃，
返回跳点或 None。
"""
nx, ny = x + dx, y + dy
if not self.is_valid(nx, ny):
return None
# 如果到达目标节点，直接返回
if (nx, ny) == self.end:
return (nx, ny)
# 检查是否是关键节点（跳点）
if dx != 0 and dy != 0: # 对角线方向
if (self.is_valid(nx - dx, ny + dy) and not self.is_valid(nx - dx, ny)) or \
(self.is_valid(nx + dx, ny - dy) and not self.is_valid(nx, ny - dy)):
return (nx, ny)
else: # 水平或垂直方向
if dx != 0: # 水平方向
if (self.is_valid(nx + dx, ny + 1) and not self.is_valid(nx, ny + 1)) or \
(self.is_valid(nx + dx, ny - 1) and not self.is_valid(nx, ny - 1)):
return (nx, ny)
elif dy != 0: # 垂直方向
if (self.is_valid(nx + 1, ny + dy) and not self.is_valid(nx + 1, ny)) or \
(self.is_valid(nx - 1, ny + dy) and not self.is_valid(nx - 1, ny)):
return (nx, ny)
# 递归跳跃到下一个节点
return self.jump(nx, ny, dx, dy)
def identify_successors(self, current):
"""
确定当前节点的后继跳点
"""
successors = []
x, y = current
for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1), (-1, -1), (-1, 1), (1, -1), (1, 1)]:
jump_point = self.jump(x, y, dx, dy)
if jump_point:
successors.append(jump_point)
return successors
def search(self):
"""
主搜索逻辑
"""
heapq.heappush(self.open_set, (self.f_score[self.start], self.start))
while self.open_set:
_, current = heapq.heappop(self.open_set)
if current == self.end:
# 回溯路径
path = []
while current in self.came_from:
path.append(current)
current = self.came_from[current]
path.append(self.start)
return path[::-1]
for successor in self.identify_successors(current):
tentative_g_score = self.g_score[current] + self.heuristic(current, successor)
if successor not in self.g_score or tentative_g_score < self.g_score[successor]:
self.came_from[successor] = current
self.g_score[successor] = tentative_g_score
self.f_score[successor] = tentative_g_score + self.heuristic(successor, self.end)
heapq.heappush(self.open_set, (self.f_score[successor], successor))
return [] # 无法到达终点，返回空路径
三、总结
- BFS 是无权图最经典的算法，适合绝大多数无权图。
- A* 引入启发式思想，在规则网格或路径规划中表现更优。
- 跳点搜索（JPS） 是对规则网格地图的高度优化算法，适合大规模的寻路问题。
根据具体场景选择合适的算法，能够显著提升效率！
扫一扫
6877
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
