【原创】5分钟拿下Floyd算法

问题描述

一天小明捧着一本世界地图在看，突然小明拿起笔，将他最爱的那些城市标记出来，并且随机的将这些城市中的某些用线段两两连接起来。
小明量出了每条线段的长度，现在小明想知道在这些线段组成的图中任意两个城市之间的最短距离是多少。

输入包含多组测试数据。
每组输入第一行为两个正整数n（n<=10）和m（m<=n*(n-1)/2），n表示城市个数，m表示线段个数。
接下来m行，每行输入三个整数a，b和l，表示a市与b市之间存在一条线段，线段长度为l。（a与b不同）
每组最后一行输入两个整数x和y，表示问题：x市与y市之间的最短距离是多少。（x与y不同）
城市标号为1~n，l<=20。

算法流程

需要维护一个dist，dist[a][b] = l，表示从a点到b点需要的距离（权重）。
如果没有给出两点之间的权重，我们认为这两个点之间无限远，为了防止相加超出整数范围，INF = Integer.MAX_VALUE / 2 。

import java.util.*;
class Main{
    public static final int INF = Integer.MAX_VALUE / 2;
    public static void main (String[] args) {
        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNext()){
            // n个城市
            int n = scanner.nextInt();
            // m条线段
            int m = scanner.nextInt();
            //dist[a][b]=l，a，b两个顶点的举例是l。
            int [][] dist = new int [n + 1][n + 1];
            
            // 初始化dist矩阵  自己到自己的距离是0，默认是INF，最大值。
            for(int i = 1 ;i <= n ; i ++){
                for(int j = 1 ; j <= n ; j ++){
                    if(i == j){
                        dist[i][j] = 0;
                    }else{
                        dist[i][j] = INF;
                    }
                }
            }
            // 放入我们的数据
            while(m -- > 0){
                int a = scanner.nextInt();
                int b = scanner.nextInt();
                int l = scanner.nextInt();
                // 放入dist
                for(int i = 1 ; i <= n ; i ++){
                    for(int j = 1 ;j <= n ; j ++){
                        //无向图，a到b，b到a距离一样
                        dist[a][b] = l;
                        dist[b][a] = l;
                    }
                }
            }
            // 算法核心部分 计算图中所有顶点对的最小距离
            
            // 遍历每个顶点，将i作为其他所有顶点对的中转点。
            for(int i = 1 ; i <= n ; i++){
                // 遍历所有路径可能的起始点
                for(int j = 1 ; j <= n ; j ++){
                    // 遍历所有路径可能的终点
                    for(int k = 1 ; k <= n ; k ++){
                        // 如果，起点到中转点的距离 + 中转点到终点的距离 < 起始点到终点的距离
                        if(dist[j][i] + dist[i][k] < dist[j][k]){
                            // 起始点到终点的距离 == 起点到中转点的距离 + 中转点到终点的距离
                            dist[j][k] = dist[j][i] + dist[i][k];
                        }
                    }
                }
            }
            // 读取要查询的两个城市
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            System.out.println(dist[x][y] == INF ? "No path" : dist[x][y]);
            
        }
        
    }
}

5分钟拿下

该算法用来找出图中所有顶点对之间的最小距离。注意，所有顶点对之间的最小距离，最后都放在dist里了。

这里说成距离不好理解，其实算的是一种权重。

我们举一个简单的例子，从家到学校（我们看成两个节点），之前你一直是坐豪华轿车，需要花10块钱（看成两点之间的距离权重）。
后来你家破产了，10块钱都没有了，于是你要寻找一种最便宜，最经济的方法。你有很多认识的同学，i1，i2，i3（不同节点）。
你在想，我先坐公交去他们家，然后再坐公交去学校，这样可能便宜很多。于是你找了所有的同学，一个一个尝试，先从你家到同学家，再从同学家到学校。
过程中，你自己维护了一个dist，每次有新的省钱路径，你都记录到dist中，这样最后，从你家到学校的那个dist，就是最便宜的（最短距离/权重）。

当然，这只是其中一个简化的模型，我们分析一下下面的代码：

• 第一层for循环：就是找所有人的家（节点），把每个人的家作为中间点。

• 第二层for循环：就是找所有的起点，这里我们维护的dist，是图中所有节点之间的最小权重。因为只有把图中的所有节点都跑一遍，你才能发现最省钱的路径。

• 第三层for循环：找所有的终点。

• 如果，起点到中转点的距离 + 中转点到终点的距离 < 起始点到终点的距离，就更新起始点到终点的距离。

在算法中，你不仅检查了朋友的家，而且检查了所有人的家（不愧是你）。这就确保了你找到了最短的路径，因为你没有忽略任何可能的路线。这就是Floyd-Warshall算法之所以能够得出正确答案的原因。

   // 遍历每个顶点，将i作为其他所有顶点对的中转点。
   for(int i = 1 ; i <= n ; i++){
       // 遍历所有路径可能的起始点
       for(int j = 1 ; j <= n ; j ++){
           // 遍历所有路径可能的终点
           for(int k = 1 ; k <= n ; k ++){
               // 如果，起点到中转点的距离 + 中转点到终点的距离 < 起始点到终点的距离
               if(dist[j][i] + dist[i][k] < dist[j][k]){
                   // 起始点到终点的距离 == 起点到中转点的距离 + 中转点到终点的距离
                   dist[j][k] = dist[j][i] + dist[i][k];
               }
           }
       }
   }

如果觉得写的不错，可以点一个关注~