最短路径之Dijkstra算法与Floyd 算法

Dijkstra算法

Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法,用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。

思想

以起始点为中心向外层层扩展，直到扩展到终点为止。

算法步骤

a.初始时，S只包含源点，即S＝{v}，v的距离为0。U包含除v外的其他顶点，即:U={其余顶点}，若v与U中顶点u有边，则<u,v>正常有权值，若u不是v的出边邻接点，则<u,v>权值为∞。

b.从U中选取一个距离v最小的顶点k，把k，加入S中（该选定的距离就是v到k的最短路径长度）。

c.以k为新考虑的中间点，修改U中各顶点的距离；若从源点v到顶点u的距离（经过顶点k）比原来距离（不经过顶点k）短，则修改顶点u的距离值，修改后的距离值的顶点k的距离加上边上的权。

d.重复步骤b和c直到所有顶点都包含在S中。

##代码

int Dijkstra(int pos1, int pos2, int adjMatrix[][MAX], size_t N) {
    int shortPathTable[MAX]; //  记录pos1到达各点的最小距离
    bool isFinal[MAX];    //  记录各点当前是否存在最小距离，是否到达各点
    
    for (int i = 0; i < N; i++) {
        //  将pos1能到的顶点全部放进
        isFinal[i] = 0;
        shortPathTable[i] = adjMatrix[pos1][i];
    }
    isFinal[pos1] = 1;
    
    int k = -1;  //  记录当前可到达距离最小的点
    for (int i = 1; i < N; i++) {   //  循环n-1次把其余n-1个点的最小距离全部找出
        k = -1;
        int min = MAXINT;
        for (int j = 0; j < N; j++) {   //  寻找当前可到达距离最小的点
            if (!isFinal[j] && shortPathTable[j] < min) {
                k = j;
                min = shortPathTable[j];
            }
        }
        
        if (k == -1) break; //  若无点可去，跳出循环
        
        isFinal[k] = 1;
        
        for (int j = 0; j < N; j++) {
            if (!isFinal[j] && (min + adjMatrix[k][j] < shortPathTable[j])) {
                shortPathTable[j] = min + adjMatrix[k][j];
            }
        }
    }
    if (shortPathTable[pos2] == MAXINT) return -1;
    return shortPathTable[pos2];
}

Floyd 算法

Floyd-Warshall算法（Floyd-Warshall algorithm）是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权的最短路径问题，同时也被用于计算有向图的传递闭包。Floyd-Warshall算法的时间复杂度为O(N3)，空间复杂度为O(N2)。

算法思想原理

Floyd算法是一个经典的动态规划算法。用通俗的语言来描述的话，首先我们的目标是寻找从点i到点j的最短路径。从动态规划的角度看问题，我们需要为这个目标重新做一个诠释（这个诠释正是动态规划最富创造力的精华所在）

从任意节点i到任意节点j的最短路径不外乎2种可能，1是直接从i到j，2是从i经过若干个节点k到j。所以，我们假设Dis(i,j)为节点u到节点v的最短路径的距离，对于每一个节点k，我们检查Dis(i,k) + Dis(k,j) < Dis(i,j)是否成立，如果成立，证明从i到k再到j的路径比i直接到j的路径短，我们便设置Dis(i,j) = Dis(i,k) + Dis(k,j)，这样一来，当我们遍历完所有节点k，Dis(i,j)中记录的便是i到j的最短路径的距离

精简版核心代码

 void Floyd(){
     int i,j,k;
     for (k = 0; k < n; k++)
         for (i = 0; i < n; i++)
             for (j = 0; j < n;j++)
                 if (dist[i][k] + dist[k][j] < dist[i][j])
                     dist[i][j] = dist[i][k] + dist[k][j];
 }

##关于Floyd算法打印路径
1、首先要给多一个保留路径的矩阵
2、每次变化记录该变化必须用到的点（具体看代码）

int Floyd(int pos1, int pos2, int adjMatrix[][MAX], size_t N, vector<string> posName) {
    int dist[MAX][MAX];
    int pathMatrix[MAX][MAX];
    //  init
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            dist[i][j] = adjMatrix[i][j];
            pathMatrix[i][j] = j;    //  初始化为必需经过它自己
        }
    }
    //  simplify
    for (int k = 0; k < N; k++) {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (dist[i][k] + dist[k][j] < dist[i][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j];
                    pathMatrix[i][j] = pathMatrix[i][k];    //路径设置为下标为k的顶点
                }
            }
        }
    }
    //  路径输出
    int k = pathMatrix[pos1][pos2];
    cout << posName[pos1];
    while (k != pos2) {
        cout << " -> " << posName[k];
        k = pathMatrix[k][pos2];
    }
    cout << " -> " << posName[pos2];
    
    return dist[pos1][pos2] == MAXINT ? -1 : dist[pos1][pos2];
}

参考：最短路径—Dijkstra算法和Floyd算法、《大话数据结构》