最短路径之弗洛伊德算法

迪杰斯特拉算法VS弗洛伊德算法

迪杰斯特拉算法是求单源最短路径，通过选定的被访问顶点，求出从出发访问顶点到其他顶点的最短路径；弗洛伊德算法中每一个顶点都是出发访问点，所以需要将每一个顶点看做被访问顶点，求出从每一个顶点到其他顶点的最短路径。

弗洛伊德算法比迪杰斯特拉算法好实现，但是时间复杂度要更高。

思路

1. 设置顶点V_i到顶点V_k的最短路径已知为L_ik，顶点V_k到V_j的最短路径已知为L_kj，顶点V_i到V_j的路径为L_ij，则V_i到V_j的最短路径为：min((L_ik+L_kj),L_ij)，V_k的取值为图中所有顶点，则可获得V_i到V_j的最短路径；
2. 至于Vi到Vk的最短路径L_ik或者Vk到V_j的最短路径L_kj，是以同样的方式获得。

实现

package com.ex.greedy;

public class Floyd {
    static final int N = 10000;// 表示不可以连接
    public static void main(String[] args) {
        char[] vertex = { 'A', 'B', 'C', 'D', 'E' };
        //邻接矩阵
        int[][] matrix ={
                {0,4,N,2,N},
                {4,0,4,1,N},
                {N,4,0,1,3},
                {2,1,1,0,7},
                {N,N,3,7,0}
        };
        floyd(matrix,vertex);
    }

    public static void floyd(int[][] matrix, char[] vertex) {
        //准备
        int n=vertex.length;
        String path[][]=new String[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                path[i][j]=vertex[i]+"—>"+vertex[j];
            }
        }
        //循环
        for (int k = 0; k < vertex.length; k++) {//中间顶点
            for (int i = 0; i < vertex.length; i++) {//起始顶点
                for (int j = 0; j < vertex.length; j++) {//终点
                    //len记录从i出发，经过k，到达j的距离
                    int len=matrix[i][k]+matrix[k][j];
                    if (len<matrix[i][j]){
                        matrix[i][j]=len;
                        path[i][j]=path[i][k].substring(0,path[i][k].length()-1)+path[k][j];//A->D D->E 前面的终点是后面的起点，不重复记录
                    }
                }
            }
        }
        //输出
        for (int i = 0; i < vertex.length; i++) {
            for (int j = 0; j < vertex.length; j++) {
                System.out.printf("%-24s",matrix[i][j]+"（["+vertex[i]+":"+vertex[j]+"]  "+path[i][j]+"）");
            }
            System.out.println();
        }

    }
}