昨天复习了一下单源最短路径问题,今天总结一下。
解决单源最短路径问题,我们熟知的算法首先就是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 E
void 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|+
545



被折叠的 条评论
为什么被折叠?



