2020/11/08 floyd算法

题目

给定一个n个点m条边的有向图，图中可能存在重边和自环，边权可能为负数。

再给定k个询问，每个询问包含两个整数x和y，表示查询从点x到点y的最短距离，如果路径不存在，则输出“impossible”。

数据保证图中不存在负权回路。

输入格式
第一行包含三个整数n，m，k

接下来m行，每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。

接下来k行，每行包含两个整数x，y，表示询问点x到点y的最短距离。

输出格式
共k行，每行输出一个整数，表示询问的结果，若询问两点间不存在路径，则输出“impossible”。

数据范围
1≤n≤200,
1≤k≤n2
1≤m≤20000,
图中涉及边长绝对值均不超过10000。

输入样例：
3 3 2
1 2 1
2 3 2
1 3 1
2 1
1 3
输出样例：
impossible
1

算法说明

弗洛伊德算法用于多源汇路径,也就是想同一个图不同源的最短路径.可以应用于负边的情况.
核心算法是用三重循环实现的,最外重是中间值,内两重是起始于终点.
存储方式使用邻接矩阵来保存最短路径,从最开始保存的边经过一次次的迭代,最终就是我们要的最短路径.

定义变量

• 邻接矩阵要定义二维数组g[][]
• 无穷值INF为0x3f3f3f3f

源代码

import java.util.*;
class Main{
    static int INF=0x3f3f3f3f;
    static int N=210;
    static int[][] g=new int[N][N];
    static int n;
    static int m;
    static int k;
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        m=sc.nextInt();
        k=sc.nextInt();
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(i==j) g[i][j]=0;
                else g[i][j]=INF;
            }
        }
     
        while(m-->0){
            int x=sc.nextInt();
            int y=sc.nextInt();
            int z=sc.nextInt();
            g[x][y]=Math.min(g[x][y],z);
        }
        floyd();
        while(k-->0){
            int x=sc.nextInt();
            int y=sc.nextInt();
            int res=g[x][y];
            if(res>INF/2) System.out.println("impossible");
            else System.out.println(res);
        }
    }
    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++){
                    g[i][j]=Math.min(g[i][j],g[i][k]+g[k][j]);
                }
            }
        }
    }
}

注意的点

1.因为可能有重边或自环,因此并不是有边加入就直接更新数组,而是取两点间的最小值
2. 因为负权边的存在,比较是否能达用的是>INF/2