弗洛伊德算法求最短路径

与迪杰斯特拉算法不同，该算法是一次性将所有顶点到其他顶点的最短路径都求出来，所以需要创建二维数组而不是一位数组

迪杰斯特拉算法求最短路径：https://mp.csdn.net/postedit/91039103

1.首先建立一个二维的邻接矩阵

顶点集合{v0,v1,v2,v3,v4}  边集{（v0,v1,1）,(v1,v2,2),(v2,v3,3),(v3,v4,4),(v4,v0,5),(v1,v4,3)}  (起点，终点，权值)

0           1          65535   65535   5   
1           0          2           65535   3   
65535   2          0           3           65535   
65535   65535  3           0           4   
5           3          65535   4           0   

注意：0代表到自身没有边，权值为0   65535 代表与其他顶点没有边，权值无穷大

2.实现与测试

图的数据结构

public class Graph {
    String[] vertex = new String[5];    //顶点类型可自定义
    int[][] edge = new int[5][5];       //边的类型可自定义

//省略get,set方法}

public class ShotestPath {

/**
     * 弗洛伊德算法求最短路径
     * 关键步骤： showtestPath1[i][j] = min{shotestPath1[i][j], shotestPath[i][k]+showtestPath[k][j]}
     * k表示经过的顶点
     *
     * 该算法求的是所有顶点到其他顶点的最短路径
     * @param g
     */
    public static void shotestPath_floyd(Graph g){
        int[][]shotestPath = new int[100][100];  //因为是求所有顶点到其他顶点的最短路径
                                                // shotestpath[i][j]代表每一行i对应的顶点i到其他顶点vj的最短路径
        int[][]passAdjvex = new int[100][100]; //passAdjvex[i][j] 代表每一行i对应的顶点vi到其他顶点vj的最短路径中，
                                                // 下一个顶点必须经过的顶点

        /**
         * 数组初始化
         */
        for(int i = 0; i < g.getVertex().length; i++){
            for(int j = 0; j < g.getVertex().length; j++){
                shotestPath[i][j] = g.getEdge()[i][j];
                passAdjvex[i][j] = j;     //有讲究第j列必须是j,因为第j列要么存放终点，要么存放最短路径必须经过的顶点
            }
        }

        //此时 shotestPaht的每一行i 代表顶点i到其他顶点的最短路径；如果顶点到其他顶点没有边，最短路径就是无穷，此处用65536代替
        //顶点到自身的路径 用0 代替

        for(int k= 0; k < g.getVertex().length; k++){  //表示所有顶点目前和各顶点的最短路径  与  经过k顶点所计算的路径相比

            for(int i = 0; i < g.getVertex().length; i++){      //表示第i行 也就是最短路径的起点
                for(int j = 0; j < g.getVertex().length; j++){      //表示第j列 也就是最短路径的终点
                    if(shotestPath[i][j] > shotestPath[i][k] + shotestPath[k][j]){   //如果顶点i 到顶点j的路径  大于
                                                                                    //顶点i到顶点k再到顶点j的路径
                        shotestPath[i][j] = shotestPath[i][k] + shotestPath[k][j];
                        passAdjvex[i][j] = passAdjvex[i][k];  //表示经过该顶点 路径更短  记录该顶点的位置
                    }
                }
            }
        }

        System.out.println("最短路径的权值：");
        for(int i = 0; i < g.getVertex().length; i++){
            for(int j = 0; j < g.getVertex().length; j++){
                System.out.print(shotestPath[i][j] + "     ");
            }
            System.out.println();
        }
        System.out.println("最短路径：");
        for(int i = 0; i < g.getVertex().length; i++){
            for(int j = 0; j < g.getVertex().length; j++){
                System.out.print(passAdjvex[i][j] + "     ");
            }
            System.out.println();
        }
    }
}

3.测试结果：

最短路径的权值：
0     1     3     6     4     
1     0     2     5     3     
3     2     0     3     5     
6     5     3     0     4     
4     3     5     4     0     
最短路径：
0     1     1     1     1     
0     1     2     2     4     
1     1     2     3     1     
2     2     2     3     4     
1     1     1     3     4   

4.

最短路径的权值     矩阵第一行表示v0到各个顶点（包括自身）的最短路径

最短路径  矩阵   比如求v0到v4的最短路径   过程如下：

                 首先看第0行4列  不是4，而是1说明  必须经过v1，进而转换成v1到v4的路径   此时路径为：v0->v1

                 接着看 第1行4列  是4，说明已经到达了终点     最短路径为：v0 -> v1 ->v4