单源最短路径复习--Dijkstra算法和Floyd算法

昨天复习了一下单源最短路径问题，今天总结一下。

解决单源最短路径问题，我们熟知的算法首先就是Dijkstra算法了。Dijkstra算法的核心就是贪心思想。我在以前的博客中也写过这个算法：图的拓扑排序、关键路径、最短路径算法 – C++实现，现在看以前的博客，我的代码思路还是很清晰的。Dijkstra算法可以求出某一点到其他所有点的最短路径，本文还将介绍一种可求出所有点对的最短路径的算法——Floyd算法。

Dijkstra算法

Dijkstra算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，知道扩展到终点为之。Dijkstra算法的要求是图中不存在负权边。因为Dijkstra算法基于贪心策略，它是短视的。如果存在某个路径上有负权边，可能绕了几圈得到的结果甚至是更优的，所以Dijkstra算法在有负权边的图应用上是失败的。

Dijkstra算法的具体解释我就不说了，如果不明白概念可参考这篇博客的概念解释：最短路径—Dijkstra算法和Floyd算法。

本文所有测试用例所用graph就是下面这幅图片中的graph：

下面给出我的代码：

#include <iostream>#include <vector>#include <iomanip>#include <limits.h>const int NUM_VERTICES = 5;  //A B C D Evoid print_solution(std::vector<int>& dist, std::vector<int>& path){    for(auto i : dist)        std::cout<<std::setw(3)<<i<<' ';    std::cout<<std::endl;    for(auto i : path)        std::cout<<std::setw(3)<<i<<' ';    std::cout<<std::endl;}void dijkstra(std::vector<std::vector<int>>& graph, int source){ std::vector<int> dist(NUM_VERTICES, 0), path(NUM_VERTICES, -1);    for(int i=1; i<NUM_VERTICES; ++i){        dist[i] = graph[source][i] == 0 ? INT_MAX : graph[source][i];        path[i] = source;    }       std::vector<bool> visited(NUM_VERTICES, false);    visited[source] = true;    for(int i=0; i<NUM_VERTICES-1; ++i){        int min = INT_MAX;        int min_index = -1;        for(int j=0; j<NUM_VERTICES; ++j){            if(!visited[j] && dist[j] < min){                min = dist[j];                min_index = j;            }        }        visited[min_index] = true; for(int k=0; k<NUM_VERTICES; ++k){            int weight = graph[min_index][k] == 0 ? INT_MAX : graph[min_index][k];            if(!visited[k] && weight != INT_MAX                           && dist[min_index] != INT_MAX                           && dist[min_index]+weight < dist[k]){                dist[k] = dist[min_index] + weight;                path[k] = min_index;            }        }    }    print_solution(dist, path);}int main(){    std::vector<std::vector<int>>    graph = {{0,  10, 0,  30, 100}, //A             {0,  0,  50, 0,  0  }, //B             {0,  0,  0,  0,  10 }, //C             {0,  0,  20, 0,  60 }, //D             {0,  0,  0,  0,  0  }};//E          //  A   B   C   D   E    dijkstra(graph, 0);  //param 0 means vertex 'A'    return 0;}                    

输出结果：

Dijkstra算法的时间复杂度是O(|E|+|V|2|)=O(V2)（参考：Dijkstra算法时间复杂度）。对于稠密的图来说，|E| 就是|V|^2，所以Dijsstra算法中遍历dist[min_index]+weigth那个循环加上最外层循环时间复杂度为θ(|V|2)，对于稠密图，这就是最优的了，总的时间复杂度正好是θ(|E|+|V|2)=θ(|V|2+|V|2)=O(|V|2)。但是对于非稠密图，这个 |E| 实际没这么大，甚至 |E|=|V|，这个算法就未免效率低下了。

优化法方法是使用最小堆，我们dist[min_Index]+weight小于dist[k]时，将新的dist[k]的值插入最小堆；在上面查找最小值的操作中，每次从最小堆中取出最小值，并且检查是否visited，如果没visited，那就找到新的顶点了。改进后的算法时间复杂度是O(|E|lg|V|)。

Floyd算法

Floyd算法是解决任意两点间最短路径的一种算法，可以正确处理负权图的最短路径问题。

上面的Dijkstra算法求出了某个点到其他所有点的最短路径，我们要求所有点对的最短路径，有这样一种思路，就是再外面再循环 |V| 次，那么不就求出所由点对的最短路径了吗？时间复杂度为O(N3)。

不过，Dijkstra算法为我们提供了一种动态规划的思想，一个点到另外一个点的最短路径，要么直接到达就是最短的，要么就是经过了一个已经最优化的点间接到达这个点就是最短的，只有这么两种情况。Floyd算法就根据这个思路把所有情况同过DP表的方式计算出来，时间复杂度是一样的，也是O(N3)，不过Floyd算法简洁的多。

Floyd算法DP公式：

D0[V][W]=min{D−1[V][W],D−1[V][K]+D−1[K][W]}

D是一个二维矩阵，是一个辅助矩阵，初始状态和graph是一致的，通过该矩阵的变化，我们来修正path矩阵的值即可。

更多的关于Floyd算法的解释参见： 数据结构之最短路径（Floyd） ，包括我下面用的打印函数，可以参见它的解释。不过它的打印函数对于非强连通图有一点问题，我加以修正了。

打印函数实际上意思就是，比如我要找(0, 8)的最短路径，如果path[0][8]的值为k，说明0->8之间经过路径k，且0->k的结果是最优的，所以目前找到了所求路径的一部分{0, k1}。然后我们再次查找(k, 8)的最短路径，看它们两之间有没有中间更优化的路径，比如找到，如果有，那就找到了路径{0, k1, k2}，依次下去，知道path[k][8]的结果为8，说明没有了。总的路径就是{0, k1, k2 … 8}。

下面给出我的代码：

#include <iostream>#include <vector>#include <iomanip>#include <limits.h>const int NUM_VERTICES = 5;  //A B C D Evoid print_solution(std::vector<std::vector<int>>& helper, std::vector<std::vector<int>>& path){    for(int i=0; i<NUM_VERTICES; ++i){        for(int j=i+1; j<NUM_VERTICES; ++j){            if(helper[i][j] == INT_MAX)                continue;            std::cout<<i<<"->";            int k = path[i][j];            while(k != j){                std::cout<<k<<"->";                k = path[k][j];     }            std::cout<<j<<std::endl;        }    }}void floyd(std::vector<std::vector<int>>& graph){    std::vector<std::vector<int>>    helper(NUM_VERTICES, std::vector<int>(NUM_VERTICES)),    path(NUM_VERTICES, std::vector<int>(NUM_VERTICES));    for(int i=0; i<NUM_VERTICES; ++i){        for(int j=0; j<NUM_VERTICES; ++j){            helper[i][j] = graph[i][j] == 0 ? INT_MAX : graph[i][j];            path[i][j] = j;        }    }    for(int k=0; k<NUM_VERTICES; ++k){      for(int i=0; i<NUM_VERTICES; ++i){            for(int j=0; j<NUM_VERTICES; ++j){                if(helper[i][k] != INT_MAX && helper[k][j] != INT_MAX                                           && helper[i][j] > helper[i][k] + helper[k][j]){                    helper[i][j] = helper[i][k] + helper[k][j];                    path[i][j] = k;                }            }        }    }    print_solution(helper, path);}int main(){    std::vector<std::vector<int>>    graph = {{0,  10, 0,  30, 100}, //A             {0,  0,  50, 0,  0  }, //B             {0,  0,  0,  0,  10 }, //C             {0,  0,  20, 0,  60 }, //D             {0,  0,  0,  0,  0  }};//E          //  A   B   C   D   E    floyd(graph);  //param 0 means vertex 'A'    return 0;}

输出结果：