Dijkstra最短路径---贪心

问题描述：

从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径，称为最短路径

Dijkstra算法思想：

该算法是解决单源最短路径的贪心算法，算法先从顶点集合中找到一个到源点最短路径的顶点，并将其从顶点集合中去掉，然后再从剩下的顶点集合中找到一个次最短距离的顶点，并将其从集合中去点，最后到顶点集合为空时，算法结束,最开始选择离源点最近的点t，将其从集合中去掉，再从集合中选择离源点最近的顶点j，因为源点到t已经是到顶点t的最短距离了，如果t是j的邻接点（t到j有边），则可以通过源点到t+t到j的距离，也就是dist[t]+map[t][j]和直接从源点到j的距离作比较选择小的那个距离，更新dist[j]，代码中维护四个数组，其中map数组是邻接矩阵，两个顶点i，j有边则将其map[i][j]赋值为边的权值，否则为INF，dist数组为距离数组表示源点到i的最短距离，flag标志数组，p数组表示i的前驱顶点，Dijkstra算法时间复杂度为O(n^2)，但是不能处理权值为负数的情况。

执行动画:

代码：

1. #include <iostream>
2. #include <algorithm>
3. #include <stack>
4. using namespace std;
5. const int N = 100;//最大顶点
6. const int INF = 1e7;
7. int map[N][N], dist[N], p[N], n, m;
8. bool flag[N];//标志顶点有没有被访问过
9. void Dijkstra(int u)
10. {
11.     int i, j;
12.     for (i = 1; i <= n; i++)
13.     {
14.         dist[i] = map[u][i];//u到i的距离
15.         flag[i] = false;
16.         if (dist[i] == INF)//u不能到i
17.         {
18.             p[i] = -1;
19.         }
20.         else//i的前驱是u
21.         {
22.             p[i] = u;
23.         }
24.     }
25.     dist[u] = 0;
26.     flag[u] = true;
27.     for (i = 1; i <= n; i++)
28.     {
29.         int temp = INF, t = u;
30.         for (j = 1; j < n; j++)//找一个离源顶点最近的顶点
31.         {
32.             if (!flag[j] && temp > dist[j])
33.             {
34.                 t = j;
35.                 temp = dist[j];
36.             }
37.         }
38.         if (t == u)return;//没找到
39.         flag[t] = true;//标记访问
40.         for (j = 1; j <= n; j++)
41.         {
42.             if (!flag[j] && map[t][j] < INF)//没被访问并且t是j的前驱等价与map[t][j]有值
43.             {
44.                 if (dist[j] > dist[t] + map[t][j])
45.                 {
46.                     dist[j] = dist[t] + map[t][j];
47.                     p[j] = t;
48.                 }
49.             }
50.         }
51.     }
52. }
53. //打印路径
54. void findPath(int u)
55. {
56.     int i,x;
57.     stack<int> s;
58.     for (i = 1; i<= n; i++)
59.     {
60.         x = p[i];
61.         while (x != -1)
62.         {
63.             s.push(x);
64.             x = p[x];
65.         }
66.         while (!s.empty())
67.         {
68.             cout << s.top() << "->";
69.             s.pop();
70.         }
71.         cout << i << "  最短路径:" << dist[i]<<endl;
72.     }
73. }
74. int main()
75. {
76.     int i, j;
77.     int u, v, w;
78.     cin >> n >> m;
79.     //map数组初始化
80.     for (i = 1; i <= n; i++)
81.     {
82.         for (j = 1; j <= n; j++)
83.         {
84.             map[i][j] = INF;
85.         }
86.     }
87.     while (m--)
88.     {
89.         cin >> u >> v >> w;
90.         map[u][v] = min(map[u][v], w);//邻接矩阵保留最小距离
91.     }
92.     int start;
93.     cin >> start;
94.     Dijkstra(start);
95.     for (i = 1; i <= n; i++)
96.     {
97.         cout << start << "---" << i << ":";
98.         if (dist[i] != INF)
99.         {
100.             cout << dist[i] << endl;
101.         }
102.     }
103.     findPath(start);
104.     return 0;
105. }