最短路径之迪杰斯特拉算法

本文将讲解图中最短路径的求解算法之一——迪杰斯特拉算法。

最短路径

在网图和非网图中，最短路径的含义不一样。由于非网图的边没有权值，所以它的最短路径，就是指两顶点之间经过的边数最少的路径；而对于网图来说，最短路径，是指两顶点之间经过的边上权值之和最少的路径。

求解最短路径的算法有很多，本文先讲解迪杰斯特拉算法。

迪杰斯特拉算法原理

迪杰斯特拉算法比较容易理解，它的思路大体为：从路径的源点开始，每次选择权值最短的路径，直到达到终点为止。所以迪杰斯特拉算法不是一下子就求出源点到终点的最短路径，而是一步步求出它们之间顶点的最短路径。

下面，通过图形的方式解释下迪杰斯特拉算法。

我将以上图为例，通过求顶点v0到v8的最短路径，讲解迪杰斯特拉算法的求解流程。

第一步，由于顶点v0与v1和v2连接，其中最短路径是v0到v1，故由v0走到v1：

第二步，由于顶点v1与v2、v3、v4连接，其中最短路径是v1到v2，故由v1走到v2：

第三步，由于顶点v2与v4、v5连接，其中最短路径是v2到v4，故由v2走到v4：

第四步，由于顶点v4与v3、v6、v7、v5连接，其中最短路径是v4到v3，故由v4走到v3：

第五步，由于顶点v3仅与v6连接，故由v3走到v6：

第六步，由于顶点v6与v7和v8连接，其中最短路径是v6到v7，故由v6走到v7：

最后一步，由v7走到v8：

所以最短路径为：v0 -> v1 -> v2 -> v4 -> v3 -> v6 -> v7 -> v8。

迪杰斯特拉算法实现

下面是利用Java实现的迪杰斯特拉算法。

/**
 * 迪杰斯特拉算法求最短路径
 */
public class Dijkstra {

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

    int MAXVEX;                             // 顶点个数

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

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

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

    public Dijkstra(int index){
        MAXVEX = index;
        arc = new int[MAXVEX][MAXVEX];
        pathMatrix = new int[MAXVEX];
        shortPathTable = new int[MAXVEX];
        createArc();// 生成邻接矩阵
    }

    // 生成邻接矩阵
    private void createArc() {
        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};
    }

    // Dijkstra算法，求有向图的v0顶点到其余顶点的最短路径及带权长度
    void ShortPath_Dijkstra(){
        int v,w,k=0,min;
        int[] Final = new int[MAXVEX];  //Final[w] = 1表示求得顶点v0到vk的最短路径
        for(v = 0;v < MAXVEX;v++){  //初始化数据
            Final[v] = 0;   //全部顶点初始化为未知最短路径状态
            shortPathTable[v] = arc[0][v];  //将与v0点有连线的顶点加上权值
            pathMatrix[v] = 0;      //初始化路径数组为0
        }
        shortPathTable[0] = 0;  //v0到v0的路径为0
        Final[0] = 1;           //v0到v0不需要求路径
        //开始循环，每次求得v0到某个顶点v的最短路径
        for(v = 1; v < MAXVEX;v++){
            min = INFINITY;     //当前所知离v0顶点的最近距离
            for(w = 0;w < MAXVEX;w++) {  //寻找离v0最近的顶点
                if( Final[w] == 0 && shortPathTable[w] < min) {
                    k = w;
                    min = shortPathTable[w];    //w顶点离v0顶点更近
                }
            }
            Final[k] = 1;       //将目前找到的最近的顶点置为1
            for(w = 0;w < MAXVEX;w++){  //修正当前最短路径及距离
                if(Final[w] == 0 && arc[k][w] != INFINITY && (min+arc[k][w] < shortPathTable[w])){//如果经过v顶点的路径比现在这条路径的长度短
                    //说明找到了更短的路径。修改shortPathTable和pathMatrix
                    shortPathTable[w] = min + arc[k][w]; //修改当前路径长度
                    pathMatrix[w] = k;
                }
            }
        }
    }

    public static void main(String[] args) {
        Dijkstra dijkstra = new Dijkstra(9);
        dijkstra.ShortPath_Dijkstra();
        System.out.print("v0到v8的最短路径为:");
        for(int i = 8;i >= 0;){

            if(i == 0) {
                System.out.print("v"+i);
                break;
            }
            else{
                System.out.print("v"+i+" <- ");
                i = dijkstra.pathMatrix[i];
            }
        }
    }

}

运行结果如下