java---Floyd算法---最短路(5)（每日一道算法2022.9.1）

切记有负权回路的时候不能用Floyd哦

题目
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，边权可能为负数
再给定 k 个询问，每个询问包含两个整数 x 和 y，表示查询从点 x 到点 y 的最短距离，如果路径不存在，则输出 impossible
数据保证图中不存在负权回路

第一行包含三个整数 n,m,k
接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z
接下来 k 行，每行包含两个整数 x,y，表示询问点 x 到点 y 的最短距离

输入：
3 3 2
1 2 1
2 3 2
1 3 1
2 1
1 3

输出：
impossible
1

public class 最短路_Floyd_多源最短路 {
    //初始化，d是邻接矩阵，large是正无穷，n为点的数量，m为边的数量，Q为查询次数
    public static int N = 210, large = 0x3f3f3f3f, n, m, Q;
    public static int[][] d = new int[N][N];

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt(); m = in.nextInt(); Q = in.nextInt();

        //初始化d矩阵，将自环删除，也就是设置为0即可，不考虑自环
        for (int i = 1; i<=n; i++) {
            for (int j = 1; j<=n; j++) {
                if (i == j) d[i][j] = 0;
                else d[i][j] = large;
            }
        }

        //这里接收边权数据，重边的情况只保留最短边即可
        while (m-- > 0) {
            int x = in.nextInt(), y = in.nextInt(), w = in.nextInt();
            d[x][y] = Math.min(d[x][y], w);
        }

        //用floyd对d矩阵进行更新，更新后的d矩阵存储的是x到y的最短距离
        floyd();

        //这个地方采用大于large/2和bellman ford的原因一样，可能存在负权边，就会导致虽然从起点走不到终点，但终点可能连接其他点
        //进行更新的时候会发生正无穷减去一个权重，导致终点虽然无法走通，但终点不是正无穷,那么我们直接比较一个较大的数当作正无穷就行啦
        while (Q-- > 0) {
            int x = in.nextInt(), y = in.nextInt();
            if (d[x][y] > large/2) System.out.println("impossible");
            else System.out.println(d[x][y]);
        }

    }

    //floyd三重循环，切记循环k必须是最外层，i和j可以颠倒
    public static void floyd() {
        for (int k = 1; k<=n; k++){
            for (int i = 1; i<=n; i++){
                for (int j = 1; j<=n; j++){
                    d[i][j] = Math.min(d[i][j], d[i][k] + d[k][j]);
                }
            }
        }
    }

最短路问题到此为止啦，floyd应该是最简单的最短路算法了吧（就是时间复杂度有点太高 (n^3
不过真的很好记啊嘿嘿

声明：算法思路来源为y总，详细请见https://www.acwing.com/
本文仅用作学习记录和交流