代码随想录Day62：图论（Floyd 算法精讲、A * 算法精讲、最短路算法总结、图论总结）

原创于 2025-08-26 16:19:29 发布 · 411 阅读

22 ·

CC 4.0 BY-SA版权

文章标签：

#图论 #算法 #java #数据结构 #leetcode

代码随想录专栏收录该内容

51 篇文章

订阅专栏

一、实战

Floyd 算法精讲

97. 小明逛公园

关于Floyd算法：多用于解决多源最短路问题，即求多个起点到多个终点的多条最短路径。dijkstra、Bellman都是单源最短路，即只能有一个起点。对边的权值正负没有要求，都可以处理。核心处理思路是动态规划。

思路：

确定dp数组（dp table）以及下标的含义

用 grid数组来存图，那就把dp数组命名为 grid。grid[i][j][k] = m，表示 节点i 到节点j 以[1...k] 集合中的一个节点为中间节点的最短距离为m。

以[1...k]集合为中间节点怎么理解？节点i 到节点j 的最短路径中一定是经过很多节点，那么这个集合用[1...k] 来表示。反过来想，节点i 到节点j 中间一定经过很多节点，那么你能用什么方式来表述中间这么多节点呢？所以这里的k不能单独指某个节点，k 一定要表示一个集合，即[1...k] ，表示节点1 到节点k 一共k个节点的集合。

确定递推公式

节点1 到节点9 的最短距离可以由节点1 到节点5的最短距离 + 节点5到节点9的最短距离组成，也可以有节点1 到节点7的最短距离 + 节点7 到节点9的最短距离的距离组成，要选一个最小的，毕竟是求最短路。

分两种情况：

1.节点i 到节点j 的最短路径经过节点k

grid[i][j][k] = grid[i][k][k - 1] + grid[k][j][k - 1]，节点i 到节点k 的最短距离是不经过节点k，中间节点集合为[1...k-1]，所以表示为grid[i][k][k - 1]，节点k 到节点j 的最短距离也是不经过节点k，中间节点集合为[1...k-1]，所以表示为 grid[k][j][k - 1]

2.节点i 到节点j 的最短路径不经过节点k

grid[i][j][k] = grid[i][j][k - 1]，如果节点i 到节点j的最短距离不经过节点k，那么中间节点集合[1...k-1]，表示为 grid[i][j][k - 1]

以上两者中取最小值，即： grid[i][j][k] = min(grid[i][k][k - 1] + grid[k][j][k - 1]， grid[i][j][k - 1])

dp数组如何初始化

刚开始初始化k 是不确定的，把k 赋值为 0，本题节点0 是无意义的，节点是从1 到 n。在下一轮计算的时候，就可以根据 grid[i][j][0] 来计算 grid[i][j][1]，此时的 grid[i][j][1] 就是节点i 经过节点1 到达节点j 的最小距离了。grid数组是一个三维数组，那么我们初始化的数据在 i 与 j 构成的平层。

红色的底部一层是我们初始化好的数据，注意：从三维角度去看初始化的数据很重要，影响遍历顺序

确定遍历顺序

初始化是把 k =0 的 i 和j 对应的数值都初始化了，这样才能去计算 k = 1 的时候 i 和 j 对应的数值。这就好比是一个三维坐标，i 和j 是平层，而k 是垂直向上的。遍历的顺序是从底向上一层一层去遍历。所以遍历k 的for循环一定是在最外面，这样才能一层一层去遍历，遍历 i 和 j 的话，for 循环的先后顺序无所谓。

import java.util.Scanner;

public class Main {

    // MAX_VAL 要大于最大边权（10^4），但不能太大导致加法溢出
    public static int MAX_VAL = 10005;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 1. 输入景点数 N 和道路数 M
        int n = sc.nextInt();
        int m = sc.nextInt();

        // 创建三维数组：grid[i][j][k] 表示 i -> j，只允许经过节点 1~k 时的最短距离
        int[][][] grid = new int[n + 1][n + 1][n + 1];

        // 初始化：所有距离为 MAX_VAL（表示不可达）
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                for (int k = 0; k <= n; k++) {
                    grid[i][j][k] = MAX_VAL;
                }
            }
        }

        // 自身到自身距离为 0（对所有 k 都成立）
        for (int k = 0; k <= n; k++) {
            for (int i = 1; i <= n; i++) {
                grid[i][i][k] = 0;
            }
        }

        // 输入 M 条双向道路
        for (int i = 0; i < m; i++) {
            int u = sc.nextInt();
            int v = sc.nextInt();
            int w = sc.nextInt();
            // 初始化 k=0 层：不允许任何中间节点，只能走直接边
            if (w < grid[u][v][0]) {
                grid[u][v][0] = w;
                grid[v][u][0] = w; // 无向图
            }
        }

        // Floyd-Warshall 三维递推
        // k: 当前允许使用的中间节点编号（从 1 到 n）
        for (int k = 1; k <= n; k++) {
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= n; j++) {
                    int notUseK = grid[i][j][k - 1];                    // 不经过节点 k
                    int useK = grid[i][k][k - 1] + grid[k][j][k - 1];   // 经过节点 k
                    if (grid[i][k][k - 1] < MAX_VAL && grid[k][j][k - 1] < MAX_VAL) {
                        grid[i][j][k] = Math.min(notUseK, useK);
                    } else {
                        grid[i][j][k] = notUseK; // 防止溢出
                    }
                }
            }
        }

        // 查询
        int q = sc.nextInt(); // 观景计划数量

        for (int i = 0; i < q; i++) {
            int start = sc.nextInt();
            int end = sc.nextInt();
            int result = grid[start][end][n]; // 使用所有节点中转后的最短距离
            if (result >= MAX_VAL) {
                System.out.println(-1);
            } else {
                System.out.println(result);
            }
        }

        sc.close();
    }
}

**A * 算法精讲（A star算法）**

127. 骑士的攻击

看到这道题目的第一个想法就是广搜，这也是最经典的广搜类型题目。因为本题地图足够大，且 n 也有可能很大，导致有非常多的查询，所以会超时。我们来看一下广搜的搜索过程，如图，红色是起点，绿色是终点，黄色是要遍历的点，最后从起点找到达到终点的最短路径是棕色。

关于Astar算法：广搜的改良版。有的是 Astar是 dijkstra 的改良版。如果是无权图（边的权值都是1）那就用广搜，代码简洁，时间效率和 dijkstra 差不多（具体要取决于图的稠密）如果是有权图（边有不同的权值），优先考虑 dijkstra。而 Astar 关键在于启发式函数，也就是影响广搜或者 dijkstra 从容器（队列）里取元素的优先顺序。

可以发现 BFS 是没有目的性的一圈一圈去搜索，而 A * 是有方向性的去搜索。

A * 有方向性的去搜索关键在于启发式函数。启发式函数落实到代码处，如果指引搜索的方向？从队列里取出什么元素，接下来就是从哪里开始搜索。所以启发式函数要影响的就是队列里元素的排序！这是影响BFS搜索方向的关键。

对队列里节点进行排序，就需要给每一个节点权值，如何计算权值呢？每个节点的权值为F，给出公式为：F = G + H。G：起点达到目前遍历节点的距离，H：目前遍历的节点到达终点的距离，起点达到目前遍历节点的距离 + 目前遍历的节点到达终点的距离就是起点到达终点的距离。

本题的图是无权网格状，在计算两点距离通常有如下三种计算方式：

曼哈顿距离，计算方式： d = abs(x1-x2)+abs(y1-y2)
欧氏距离（欧拉距离），计算方式：d = sqrt( (x1-x2)^2 + (y1-y2)^2 )
切比雪夫距离，计算方式：d = max(abs(x1 - x2), abs(y1 - y2))

x1, x2 为起点坐标，y1, y2 为终点坐标，abs 为求绝对值，sqrt 为求开根号，选择哪一种距离计算方式也会导致 A * 算法的结果不同。本题，采用欧拉距离才能最大程度体现点与点之间的距离。所以使用欧拉距离计算和广搜搜出来的最短路的节点数是一样的。（路径可能不同，但路径上的节点数是相同的）

曼哈顿、欧拉以及契比雪夫三种计算方式下，A * 算法的寻路过程，动画地址：https://kamacoder.com/tools/knight.html

计算出来 F 之后，按照 F 的大小，来选去出队列的节点。可以使用优先级队列帮我们排好序，每次出队列，就是F最小的节点。

拓展：

A * 算法并不是一个明确的最短路算法，A* 算法搜的路径如何，完全取决于启发式函数怎么写，并不能保证一定是最短路，因为在设计启发式函数的时候，要考虑时间效率与准确度之间的一个权衡。虽然本题中，A * 算法得到是最短路，也是因为本题启发式函数和地图结构都是最简单的。例如在游戏中，在地图很大、不同路径权值不同、有障碍且多个游戏单位在地图中寻路的情况，如果要计算准确最短路，耗时很大，会给玩家一种卡顿的感觉。

所以在游戏开发设计中，保证运行效率的情况下，A * 算法中的启发式函数设计往往不是最短路，而是接近最短路的次短路设计。

import java.util.*;

public class Main {

    // 马走日的8个方向偏移量 (dx, dy)
    private static final int[] dx = {-2, -2, -1, -1, 1, 1, 2, 2};
    private static final int[] dy = {-1, 1, -2, 2, -2, 2, -1, 1};

    // 棋盘边界：1 到 1000
    private static final int MIN = 1;
    private static final int MAX = 1000;

    // A*搜索中的节点，包含坐标、g值（起点到当前步数）、h值（启发值）、f值（g+h）
    static class Node {
        int x, y;
        int g, h, f;

        public Node(int x, int y, int g, int h) {
            this.x = x;
            this.y = y;
            this.g = g;
            this.h = h;
            this.f = g + h; // f = g + h，用于优先队列排序
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // 读取测试用例数量

        // 处理每个查询
        for (int i = 0; i < n; i++) {
            int a1 = sc.nextInt(); // 起点x
            int a2 = sc.nextInt(); // 起点y
            int b1 = sc.nextInt(); // 终点x
            int b2 = sc.nextInt(); // 终点y

            int result = astar(a1, a2, b1, b2); // A*搜索最短步数
            System.out.println(result); // 输出结果
        }

        sc.close();
    }

    // A*算法：计算从(sx,sy)到(tx,ty)的最少移动步数
    private static int astar(int sx, int sy, int tx, int ty) {
        if (sx == tx && sy == ty) return 0; // 起点即终点

        // 优先队列：按f值从小到大排序，优先扩展最有希望的节点
        PriorityQueue<Node> pq = new PriorityQueue<>(Comparator.comparingInt(n -> n.f));
        
        // gScore[i][j]：记录到达(i,j)的最小步数（g值）
        int[][] gScore = new int[MAX + 1][MAX + 1];

        // 初始化所有位置的g值为无穷大
        for (int i = 1; i <= MAX; i++)
            Arrays.fill(gScore[i], Integer.MAX_VALUE);

        // 计算起点的启发值
        int h0 = heuristic(sx, sy, tx, ty);
        pq.offer(new Node(sx, sy, 0, h0)); // 将起点加入队列
        gScore[sx][sy] = 0; // 起点步数为0

        while (!pq.isEmpty()) {
            Node current = pq.poll(); // 取出f值最小的节点
            int x = current.x, y = current.y, g = current.g;

            // 如果当前g值大于已记录的最优g值，跳过（旧数据）
            if (g > gScore[x][y]) continue;

            // 尝试8个马走日方向
            for (int i = 0; i < 8; i++) {
                int nx = x + dx[i], ny = y + dy[i]; // 新坐标
                // 检查是否越界
                if (nx < MIN || nx > MAX || ny < MIN || ny > MAX) continue;

                int newG = g + 1; // 到新位置的步数

                // 如果到达目标点，直接返回步数
                if (nx == tx && ny == ty) return newG;

                // 如果找到更短路径，更新gScore并加入队列
                if (newG < gScore[nx][ny]) {
                    gScore[nx][ny] = newG; // 更新最短步数
                    int h = heuristic(nx, ny, tx, ty); // 计算启发值
                    pq.offer(new Node(nx, ny, newG, h)); // 加入优先队列
                }
            }
        }

        return -1; // 理论上不会到达这里（骑士总能到达任意点）
    }

    // 启发函数：估计从(x,y)到(tx,ty)的最小步数（不会高估）
    // 使用 (dx² + dy²) / 5 作为启发值，避免sqrt提高效率，且保证A*最优性
    private static int heuristic(int x, int y, int tx, int ty) {
        int dx = Math.abs(x - tx);
        int dy = Math.abs(y - ty);
        return (dx * dx + dy * dy) / 5;
    }
}