一、基本思路

1、算法原理

遍历每条边，通过比较进行路径更新——暴力
解决多源最短路问题，求解 i 点到 j 点的最短距离
- f [ i, j, k] 表示从 i 走到 j 的路径上除 i 和 j 点外只经过1到k的点的所有路径的最短距离。
- 那么 f [i, j, k] = min( f [i, j, k - 1), f [i, k, k - 1] + f [k, j, k - 1]。
- 因此在计算第 k 层的 f [i, j] 的时候必须先将第 k - 1层的所有状态计算出来，所以需要把 k 放在最外层。
使用邻接矩阵 d[i][j] 进行存储

2、基本思路

 for(int kk = 1; kk <= n; kk++){
   for(int i = 1; i <= n; i++){
     for(int j = 1; j <= n; j++){
        d[i][j] = Math.min(d[i][j], d[i][kk] + d[kk][j]);      
        }
    }
}

i -----> k -----> j
用k来更新 i —> j 的距离

3、注意

1. 在进行 Floyd 算法之前需要进行邻接矩阵的初始化——考虑重边和自环

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] = INF;
   		}
   }
}

1. 结束后，d[i][j] 存的是 i —> 的最短路径

二、Java、C语言模板实现

//Java 模板实现
 for(int kk = 1; kk <= n; kk++){
   for(int i = 1; i <= n; i++){
     for(int j = 1; j <= n; j++){
        d[i][j] = Math.min(d[i][j], d[i][kk] + d[kk][j]);      
        }
    }
}

```cpp
// yxc
初始化：
    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] = INF;

// 算法结束后，d[a][b]表示a到b的最短距离
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] = min(d[i][j], d[i][k] + d[k][j]);
}

三、例题题解

在这里插入图片描述

// java题解实现
import java.util.*;

public class Main{
    static int N = 210;
    static int INF = 0x3f3f3f3f;
    static int[][] d = new int[N][N];       // 使用邻接矩阵进行边的存储，表示从i点到k点的距离值
    static int x,y,z;
    static int n,m,k;
    
    static void Floyd(){
        
        for(int kk = 1; kk <= n; kk++){
            for(int i = 1; i <= n; i++){
                for(int j = 1; j <= n; j++){
                    d[i][j] = Math.min(d[i][j], d[i][kk] + d[kk][j]);       // 将节点 k 作为中间点，进行距离更新
                }
            }
        }
    }
    
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        
        n = in.nextInt();
        m = in.nextInt();
        k = in.nextInt();
        
        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] = INF;
                }
            }
        }
        
        
        for(int i = 0; i < m; i++){
            x = in.nextInt();
            y = in.nextInt();
            z = in.nextInt();
            
            d[x][y] = Math.min(d[x][y], z);
        }
        
        
        Floyd();
        
        for(int i = 0; i < k; i++){
            x = in.nextInt();
            y = in.nextInt();
            
            if(d[x][y] > INF/2){
                System.out.println("impossible");
            }else{
                System.out.println(d[x][y]);
            }
            
        }
    }
}