最短路径之弗洛伊德算法

本文将讲解图中最短路径的求解算法之弗洛伊德算法。

在我的上一篇博客http://blog.csdn.net/yz930618/article/details/77941011中，讲解了求解最短路径的一种算法迪杰斯特拉算法。迪杰斯特拉算法是求某个顶点到其余顶点的最短路径，而本文所要讲的弗洛伊德算法则是所有顶点到所有顶点的最短路径，弗洛伊德算法十分精妙，仅通过少量代码就能实现该功能。

弗洛伊德算法原理

由于是求所有顶点到所有顶点的最短路径，所以所存储的P和D都是二维数组，其中，D表示顶点到顶点的最短路径权值之和的矩阵，P表示对应顶点的最小路径的前驱矩阵。

首先，进行初始化操作：

• D矩阵初始化为图的邻接矩阵
• P矩阵的每一行都相同，每行的值均为从0按列增加

弗洛伊德算法有三层循环：

• 第一层循环：依次将每个顶点作为中转顶点，记为Vk；
• 第二层和第三层循环：遍历所有顶点的连线情况。设Vs代表起始顶点，Ve代表结束顶点。循环内所做的操作为：判断D[Vs][Ve]与D[Vs][Vk]+D[Vk][Ve]的大小，令D[Vs][Ve]=min{D[Vs][Ve], D[Vs][Vk]+D[Vk][Ve]}，并且将P矩阵对应的P[Vs][Ve]和P[Ve][Vs]修改为当前中转顶点的下标k。通俗来说，如果D[Vs][Ve] > D[Vs][Vk]+D[Vk][Ve]，则说明顶点Vs直接到顶点Ve的距离大于先从Vs到Vk，然后再从Vk到Ve的矩阵。所以，两者取距离较短的那个。

弗洛伊德算法实现

下面是利用Java实现的弗洛伊德算法。

/**
 * 弗洛伊德算法求最短路径
 */
public class Floyd {

    int[][] arc;                            // 邻接矩阵

    int MAXVEX;                             // 顶点个数

    int INFINITY = Integer.MAX_VALUE;       // 权值最大值

    int[][] pathMatrix;                     // 用于存储最短路径下标的数组

    int[][] shortPathTable;                 // 用于存储到各点最短路径的权值和

    public Floyd(int index){
        MAXVEX = index;
        createArc();           // 生成邻接矩阵
        createPathMatrix();    // 生成pathMatrix
        createShortPathTable();// 生成shortPathTable
    }

    // 生成pathMatrix
    private void createPathMatrix() {
        pathMatrix = new int[MAXVEX][MAXVEX];
        for(int v = 0;v < MAXVEX;v++){
            for(int w = 0;w < MAXVEX;w++){
                pathMatrix[v][w] = w;
            }
        }
    }

    // 生成shortPathTable
    private void createShortPathTable() {
        shortPathTable = new int[MAXVEX][MAXVEX];
        for(int v = 0;v < MAXVEX;v++){
            for(int w = 0;w < MAXVEX;w++){
                shortPathTable[v][w] = arc[v][w];
            }
        }
    }

    // 生成邻接矩阵
    private void createArc() {
        arc = new int[MAXVEX][MAXVEX];
        this.arc[0] = new int[]{        0,       1,     5,INFINITY,INFINITY,INFINITY,INFINITY,INFINITY,INFINITY};
        this.arc[1] = new int[]{        1,       0,     3,      7,      5,INFINITY,INFINITY,INFINITY,INFINITY};
        this.arc[2] = new int[]{        5,       3,     0,INFINITY,       1,      7,INFINITY,INFINITY,INFINITY};
        this.arc[3] = new int[]{INFINITY,          7,INFINITY,      0,       2,INFINITY,    3,INFINITY,INFINITY};
        this.arc[4] = new int[]{INFINITY,     5,      1,       2,        0,       3,      6,        9,INFINITY};
        this.arc[5] = new int[]{INFINITY,INFINITY,      7,INFINITY,       3,        0,       INFINITY, 5,  INFINITY};
        this.arc[6] = new int[]{INFINITY,INFINITY,INFINITY,       3,      6,INFINITY,       0,      2,      7};
        this.arc[7] = new int[]{INFINITY,INFINITY,INFINITY,INFINITY,       9,        5,       2,    0,      4};
        this.arc[8] = new int[]{INFINITY,INFINITY,INFINITY,INFINITY,INFINITY,INFINITY,      7,        4,        0};
    }

    // Floyd算法，求有向图的所有顶点到所有顶点的最短路径及带权长度
    void ShortPath_Floyd(){
       for(int k = 0;k < MAXVEX;k++){
           for(int v = 0;v < MAXVEX;v++){
               for(int w = 0;w < MAXVEX;w++){
                   if(shortPathTable[v][k] != INFINITY && shortPathTable[k][w] != INFINITY && (shortPathTable[v][w] > (shortPathTable[v][k] + shortPathTable[k][w]))){
                        shortPathTable[v][w] = shortPathTable[v][k] + shortPathTable[k][w];
                        pathMatrix[v][w] = pathMatrix[v][k];
                   }
               }
           }
       }
    }

    public static void main(String[] args) {
        Floyd floyd = new Floyd(9);
        floyd.ShortPath_Floyd();
        for(int v = 0;v < 9;v++){
            for(int w = v+1;w < 9;w++){
                System.out.print("v"+v+" -> v"+w+" weight: "+ floyd.shortPathTable[v][w]);
                int k = floyd.pathMatrix[v][w]; //获得第一个路径顶点的下标
                System.out.print(" path: "+k);
                while (k != w){ //如果路径顶点下标不是终点
                    System.out.print(" -> "+k);
                    k = floyd.pathMatrix[k][w]; //获得下一个路径顶点下标
                }
                System.out.println(" -> " + w);
            }
            System.out.println();
        }
    }
}

结果如下