代码随想录第六十二天| Floyd 算法精讲 A * 算法精讲（A star算法）最短路算法总结篇

Floyd 算法精讲

题目描述

小明希望在公园散步时找到从一个景点到另一个景点的最短路径。给定公园的景点图，包含 N 个景点和 M 条双向道路，每条道路有已知的长度。小明有 Q 个观景计划，每个计划包含一个起点和终点，求每个计划的最短路径长度。

输入包含景点数量 N、道路数量 M，接着 M 行每行三个整数 u、v、w 表示景点 u 和 v 之间的双向道路长度为 w。然后输入观景计划数量 Q，接着 Q 行每行两个整数 start 和 end。输出每个计划的最短路径长度，若无路径则输出 -1。

输入输出示例

输入：

7 3 1 2 4 2 5 6 3 6 8 2 1 2 2 3

输出：

4 -1

解题思路

算法原理

Floyd 算法是一种多源最短路径算法，基于动态规划思想。通过引入中间节点逐步更新所有节点对之间的最短距离，最终得到全局最优解。该算法可以处理带负权的图。

动态规划思想

状态定义：grid[i][j][k] 表示从节点 i 到节点 j，只能经过节点 1 到 k 的最短距离。
状态转移：grid[i][j][k] = min(grid[i][j][k-1], grid[i][k][k-1] + grid[k][j][k-1])，即不经过节点 k 或经过节点 k 的最小值。
初始化：初始时，grid[i][j][0] 为直接连接的边的权值，其他为无穷大。
遍历顺序：按 k、i、j 的顺序遍历，确保每一步都基于之前的结果。

空间优化

由于每次计算只依赖前一次的结果，可以将三维数组优化为二维数组，减少空间复杂度。

代码实现

import java.util.Scanner;public class FloydAlgorithm {public static final int MAX_VAL = 10005; // 边的最大距离public static void main(String[] args) {Scanner sc = new Scanner(System.in);int n = sc.nextInt(); // 景点数量int m = sc.nextInt(); // 道路数量// 初始化距离矩阵int[][] grid = new int[n + 1][n + 1];for (int i = 1; i <= n; i++) {for (int j = 1; j <= n; j++) {grid[i][j] = MAX_VAL; // 初始化为最大值}}// 输入道路信息for (int i = 0; i < m; i++) {int u = sc.nextInt();int v = sc.nextInt();int w = sc.nextInt();grid[u][v] = w; // 双向道路grid[v][u] = w;}// Floyd 算法核心部分for (int k = 1; k <= n; k++) {for (int i = 1; i <= n; i++) {for (int j = 1; j <= n; j++) {// 更新 i 到 j 的最短路径if (grid[i][k] + grid[k][j] < grid[i][j]) {grid[i][j] = grid[i][k] + grid[k][j];}}}}// 处理观景计划int q = sc.nextInt(); // 计划数量for (int i = 0; i < q; i++) {int start = sc.nextInt();int end = sc.nextInt();if (grid[start][end] == MAX_VAL) {System.out.println(-1); // 无路径} else {System.out.println(grid[start][end]); // 最短路径长度}}}
}

代码注释

初始化距离矩阵：grid[i][j] 初始化为最大值，表示初始时无路径。
输入道路信息：读取每条道路并更新距离矩阵，双向道路需两边更新。
Floyd 算法核心：三重循环，逐步引入中间节点 k，更新所有节点对的最短路径。
处理观景计划：对每个计划查询最短路径，若仍为最大值则输出 -1，否则输出路径长度。

总结

Floyd 算法通过动态规划思想，利用三维数组逐步更新节点间的最短路径。空间优化后使用二维数组，时间复杂度为 O(n^3)，适合稠密图或多源最短路径问题。理解动态规划的状态转移和遍历顺序是掌握该算法的关键。

A* 算法精讲

题目描述

在象棋中，骑士（马）按照“日”字形移动。给定骑士的起始坐标和目标坐标，计算从起点到达目标点所需的最短步数。棋盘大小为 1000x1000。

输入包含多个测试用例，每行给出起点和目标点的坐标。输出每个测试用例的最短步数。

输入输出示例

输入：

输出：

解题思路

算法原理

A* 算法是一种启发式搜索算法，结合了广度优先搜索（BFS）和迪杰斯特拉算法（Dijkstra）的优点，通过引入启发式函数来指导搜索方向，从而提高搜索效率。

关键点

启发式函数：用于估计当前节点到目标节点的距离，指导搜索方向。常见的启发式函数包括曼哈顿距离、欧氏距离和切比雪夫距离。本题采用欧氏距离。
优先级队列：根据启发式函数计算的值（F = G + H）对节点进行排序，优先扩展最有可能接近目标的节点。
节点状态记录：记录已访问节点的步数，避免重复访问。

代码实现

import java.util.*;
import java.awt.Point;
import java.util.PriorityQueue;public class KnightAttack {// 定义骑士的8个可能移动方向private static final int[][] MOVES = {{-2, -1}, {-2, 1}, {-1, -2}, {-1, 2},{1, -2}, {1, 2}, {2, -1}, {2, 1}};public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int n = scanner.nextInt();for (int i = 0; i < n; i++) {int a1 = scanner.nextInt();int a2 = scanner.nextInt();int b1 = scanner.nextInt();int b2 = scanner.nextInt();System.out.println(astar(new Point(a1, a2), new Point(b1, b2)));}}private static int astar(Point start, Point end) {// 优先级队列，存储 (总代价, 当前位置, 已走步数)PriorityQueue<Node> heap = new PriorityQueue<>((a, b) -> Double.compare(a.f, b.f));heap.add(new Node(start, 0, heuristic(start, end)));// 记录访问过的节点及其步数Map<Point, Integer> visited = new HashMap<>();visited.put(start, 0);while (!heap.isEmpty()) {Node current = heap.poll();// 检查是否到达目标if (current.point.equals(end)) {return current.steps;}// 生成下一个可能的移动位置for (int[] move : MOVES) {Point nextPoint = new Point(current.point.x + move[0], current.point.y + move[1]);// 检查是否在棋盘范围内if (nextPoint.x >= 1 && nextPoint.x <= 1000 && nextPoint.y >= 1 && nextPoint.y <= 1000) {int newSteps = current.steps + 1;// 如果该位置未被访问或有更短路径if (!visited.containsKey(nextPoint) || newSteps < visited.get(nextPoint)) {visited.put(nextPoint, newSteps);double f = newSteps + heuristic(nextPoint, end);heap.add(new Node(nextPoint, newSteps, f));}}}}// 如果无法到达目标return -1;}private static double heuristic(Point start, Point end) {// 欧氏距离启发式函数double dx = start.x - end.x;double dy = start.y - end.y;return Math.sqrt(dx * dx + dy * dy);}private static class Node {Point point;int steps;double f; // 总代价：f = steps + heuristicNode(Point point, int steps, double f) {this.point = point;this.steps = steps;this.f = f;}}
}

代码注释

移动方向定义：骑士有8个可能的移动方向，用 moves 数组表示。
启发式函数：heuristic 函数计算两个点之间的欧氏距离，作为估计距离。
A 搜索函数*：astar 函数使用优先级队列进行搜索，每次扩展最有可能接近目标的节点。
优先级队列：队列中存储元组 (总代价, 当前位置x, 当前位置y, 已走步数)，按总代价排序。
访问记录：visited 字典记录已访问节点及其最小步数，避免重复访问。
输入处理：读取多个测试用例，对每个用例调用 astar 函数计算最短步数。

总结

A* 算法通过引入启发式函数，能够在大规模地图上高效地找到最短路径。相比传统的广度优先搜索（BFS），A* 算法通过优先扩展接近目标的节点，减少了不必要的搜索，提高了效率。选择合适的启发式函数对算法性能至关重要。

最短路算法总结

至此已经讲解了四大最短路算法，分别是 Dijkstra、Bellman-Ford、SPFA 和 Floyd。

针对这四大最短路算法，我用了七篇长文才彻底讲清楚，分别是：

Dijkstra 朴素版
Dijkstra 堆优化版
Bellman-Ford
Bellman-Ford 队列优化算法（又名 SPFA）
Bellman-Ford 算法判断负权回路
Bellman-Ford 之单源有限最短路
Floyd 算法精讲
启发式搜索：A * 算法

最短路算法比较复杂，而且各自有各自的应用场景。以下是讲过的最短路算法的使用场景对比表：

算法	适用场景	特点
Dijkstra	单源且边为正数	效率高，适合稀疏图和稠密图的不同版本
SPFA	单源边可为负数	一般情况下比 Bellman-Ford 效率高，适合大部分场景
Bellman-Ford	单源边可为负数，需判断负权回路	可以检测负权回路，代码实现相对简单
Floyd	多源点求最短路	适合节点数量较少的情况，实现简单

（因为 A * 属于启发式搜索，和上面最短路算法并不是一类，不适合一起对比，所以没有放在一起）

可能有同学感觉：这个表太复杂了，我记也记不住。

其实记不住的原因还是对这几个最短路算法没有深刻的理解。这里给大家一个大体使用场景的分析：

如果遇到单源且边为正数，直接 Dijkstra。至于使用朴素版还是堆优化版，还是取决于图的稠密度。多少节点多少边算是稠密图，多少算是稀疏图，这个没有量化。如果想量化，只能写出两个版本然后做实验去测试，不同的判题机得出的结果还不太一样。一般情况下，可以直接用堆优化版本。
如果遇到单源边可为负数，直接 Bellman-Ford。同样 SPFA 还是 Bellman-Ford 取决于图的稠密度。一般情况下，直接用 SPFA。
如果有负权回路，优先 Bellman-Ford。如果是有限节点最短路，也优先 Bellman-Ford，理由是写代码比较方便。
如果是遇到多源点求最短路，直接 Floyd。除非源点特别少，且边都是正数，那可以多次 Dijkstra 求出最短路径，但这种情况很少。一般出现多个源点了，就是想让你用 Floyd 了。
对于 A *，由于其高效性，在实际工程应用中使用最为广泛。由于其结果的不唯一性，也就是可能是次短路的特性，一般不适合作为算法题。游戏开发、地图导航、数据包路由等都广泛使用 A * 算法。