代码随想录训练营 Day62打卡 图论part11
Floyd 算法
例题:卡码97. 小明逛公园
题目描述
小明喜欢去公园散步,公园内布置了许多的景点,相互之间通过小路连接,小明希望在观看景点的同时,能够节省体力,走最短的路径。
给定一个公园景点图,图中有 N 个景点(编号为 1 到 N),以及 M 条双向道路连接着这些景点。每条道路上行走的距离都是已知的。
小明有 Q 个观景计划,每个计划都有一个起点 start 和一个终点 end,表示他想从景点 start 前往景点 end。由于小明希望节省体力,他想知道每个观景计划中从起点到终点的最短路径长度。 请你帮助小明计算出每个观景计划的最短路径长度。
输入描述第一行包含两个整数 N, M, 分别表示景点的数量和道路的数量。
接下来的 M 行,每行包含三个整数 u, v, w,表示景点 u 和景点 v 之间有一条长度为 w 的双向道路。
接下里的一行包含一个整数 Q,表示观景计划的数量。
接下来的 Q 行,每行包含两个整数 start, end,表示一个观景计划的起点和终点。
输出描述对于每个观景计划,输出一行表示从起点到终点的最短路径长度。如果两个景点之间不存在路径,则输出 -1。
输入示例7 3
2 3 4
3 6 6
4 7 8
2
2 3
3 4
输出示例4
-1
提示信息从 2 到 3 的路径长度为 4,3 到 4 之间并没有道路。
本题要求使用 Floyd-Warshall 算法 解决 多源最短路径 问题,具体来说,要计算每两个景点之间的最短路径。与之前学过的 Dijkstra 或 Bellman-Ford 算法不同,Floyd-Warshall 可以处理多个起点和多个终点之间的最短路径,且适用于权值为正或负的边,但不允许存在负权回路。
核心思想
Floyd-Warshall 算法的核心思想
Floyd-Warshall 算法的核心思想是通过动态规划,逐步引入中间节点来优化路径。对于每个可能的中间节点 k,检查通过该中间节点的路径是否比原有的直接路径更短。如果更短,则更新路径长度。
具体地,假设我们有 N 个节点,Floyd-Warshall 算法可以通过三重循环来计算所有节点对之间的最短路径:
- 外层循环枚举所有可能的中间节点 k。
- 中间两层循环枚举起点 i 和终点 j,并检查是否通过中间节点 k 能找到更短的路径。
递推公式为:
python
grid[i][j] = min(grid[i][j], grid[i][k] + grid[k][j])
其中:
grid[i][j] 表示节点 i 到节点 j 的最短路径。
grid[i][k] + grid[k][j] 表示通过中间节点 k 走到 j 的路径长度。
我们取两者的最小值,来不断更新最短路径。
遍历顺序
外层 k 遍历中间节点。内层 i, j 遍历所有起点和终点。
代码实现
python
if __name__ == '__main__':
max_int = 10005 # 设置一个非常大的数表示节点之间不可达
# 读取节点数 n 和边数 m
n, m = map(int, input().split())
# 初始化二维数组 grid,存储最短路径,初始值为无穷大
grid = [[max_int] * (n + 1) for _ in range(n + 1)]
# 自己到自己的最短路径为 0
for i in range(1, n + 1):
grid[i][i] = 0
# 读取边的信息,双向边,初始化各边的距离
for _ in range(m):
p1, p2, w = map(int, input().split())
grid[p1][p2] = min(grid[p1][p2], w) # 避免多条边,取最短边
grid[p2][p1] = min(grid[p2][p1], w)
# 使用 Floyd-Warshall 算法更新所有节点对之间的最短路径
for k in range(1, n + 1):
for i in range(1, n + 1):
for j in range(1, n + 1):
grid[i][j] = min(grid[i][j], grid[i][k] + grid[k][j])
# 读取 Q 个查询,输出最短路径
q = int(input()) # 观景计划数量
for _ in range(q):
start, end = map(int, input().split())
if grid[start][end] == max_int:
print(-1) # 不可达
else:
print(grid[start][end]) # 输出最短路径
A * 算法
例题:97. 小明逛公园
题目描述
在象棋中,马和象的移动规则分别是"马走日"和"象走田"。现给定骑士的起始坐标和目标坐标,要求根据骑士的移动规则,计算从起点到达目标点所需的最短步数。
棋盘大小 1000 x 1000(棋盘的 x 和 y 坐标均在 [1, 1000] 区间内,包含边界)
输入描述第一行包含一个整数 n,表示测试用例的数量,1 <= n <= 100。
接下来的 n 行,每行包含四个整数 a1, a2, b1, b2,分别表示骑士的起始位置 (a1, a2) 和目标位置 (b1, b2)。
输出描述输出共 n 行,每行输出一个整数,表示骑士从起点到目标点的最短路径长度。
输入示例6
5 2 5 4
1 1 2 2
1 1 8 8
1 1 8 7
2 1 3 3
4 6 4 6
输出示例2
4
6
5
1
0
提示信息骑士移动规则如图,红色是起始位置,黄色是骑士可以走的地方。
实现思路
本题是典型的求最短路径问题。棋盘为1000x1000,我们需要计算骑士(象棋中的"马")从起始位置移动到目标位置所需的最短步数。
骑士的移动规则 :骑士每次可以向8个不同方向移动,具体为"日"字形移动方式:即每次水平或垂直移动两格,同时在垂直或水平方向再移动一格。
A*算法:A算法是一种启发式搜索算法,使用估计代价函数来加速路径搜索。在A中,优先队列会根据状态的代价(F = G + H)来排序。
- G是从起点到当前节点的实际代价(即步数)。
- H是当前节点到目标节点的估计代价(启发式函数),可以使用欧几里得距离的平方来估算,避免开根号的浮点运算。
具体步骤:
- 定义骑士的8个可能移动方向。
- 使用优先队列(最小堆)存储每个状态,根据F值(G+H)进行排序,F值越小优先级越高。
- 初始化状态:将起点加入优先队列,开始A*搜索。
- 扩展节点:从优先队列中取出F值最小的节点,检查是否到达目标点。如果没有到达,则继续将其8个可能的移动加入优先队列。
- 剪枝:对于越界的点或已经访问过的点,跳过处理。
- 最终输出结果:当找到目标点时,输出最短步数。
代码实现
python
import heapq
# 定义骑士的8个移动方向
dir = [(-2, -1), (-2, 1), (-1, 2), (1, 2), (2, 1), (2, -1), (1, -2), (-1, -2)]
# 启发式函数,计算当前节点到目标节点的估计代价(使用欧几里得距离的平方)
def heuristic(x1, y1, x2, y2):
return (x1 - x2) ** 2 + (y1 - y2) ** 2
# A*算法函数,返回从起点到终点的最短路径
def astar(a1, a2, b1, b2):
# 初始化棋盘,用于记录每个点的最短路径步数
moves = [[0] * 1001 for _ in range(1001)]
# 定义优先队列,初始加入起点
pq = []
heapq.heappush(pq, (0, a1, a2)) # (F值, x, y)
# 处理队列,开始A*搜索
while pq:
f, x, y = heapq.heappop(pq)
# 如果当前点已经到达目标点,返回步数
if x == b1 and y == b2:
return moves[x][y]
# 扩展当前点的8个移动方向
for dx, dy in dir:
nx, ny = x + dx, y + dy
# 判断是否越界
if 1 <= nx <= 1000 and 1 <= ny <= 1000:
if moves[nx][ny] == 0: # 如果该点还没有访问过
moves[nx][ny] = moves[x][y] + 1 # 更新步数
g = moves[nx][ny] * 5 # G值,每次移动的代价是5
h = heuristic(nx, ny, b1, b2) # 计算启发式估计值H
f = g + h # 计算F值
heapq.heappush(pq, (f, nx, ny)) # 将新状态加入优先队列
return -1 # 如果无法到达目标点
# 处理输入输出
if __name__ == "__main__":
n = int(input()) # 读取测试用例数量
for _ in range(n):
a1, a2, b1, b2 = map(int, input().split()) # 读取起点和终点坐标
if a1 == b1 and a2 == b2:
print(0) # 如果起点和终点相同,步数为0
else:
print(astar(a1, a2, b1, b2)) # 输出从起点到终点的最短步数
代码详解:
-
dir:定义骑士的8个移动方向。
-
heuristic:启发式函数,计算当前节点到目标节点的欧几里得距离的平方,作为H值。
-
astar:A*搜索算法的核心函数:
使用heapq实现优先队列,按F值排序。
对于每个扩展节点,检查是否越界或已经访问过。
使用G值(步数*5)和H值计算F值,并加入优先队列。
-
输入输出处理:循环处理多个测试用例,每个测试用例根据起点和终点坐标,调用A*算法求解。
时间复杂度:
最坏情况下,骑士可能需要遍历整个1000x1000的棋盘,时间复杂度约为O(NlogN),其中N是棋盘的大小,logN来自优先队列操作。
卡码题目链接
题目文章讲解