devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

其它高阶数据结构③_图的最短路径（三种算法思想+代码实现）_最短路径三种算法

作者：知新_RL | 2024-05-26 10:19:26

赞

踩

最短路径三种算法

目录

 5. 图的最短路径

5.1 Dijkstra算法_单源最短路径

基本思想

代码实现

5.2 Bellman-Ford算法_单源最短路径

基本思想

代码实现

5.3 Floyd-Warshall算法_多源最短路径

基本思想

代码实现

本篇完。

序号跟着上一篇（懂图的基础的也可以不看上一篇，很多竞赛还是会用到图的最短路径算法的）：

 5. 图的最短路径

  • 最短路径问题：从带权有向图中的某一顶点出发，找出一条通往另一顶点的最短路径，最短指的是路径各边的权值总和达到最小，最短路径可分为单源最短路径和多源最短路径。
  • 单源最短路径指的是从图中某一顶点出发，找出通往其他所有顶点的最短路径，而多源最短路径指的是，找出图中任意两个顶点之间的最短路径。

5.1 Dijkstra算法_单源最短路径

基本思想

Dijkstra算法（迪杰斯特拉算法）的基本思想如下：

  • 将图中的顶点分为两个集合，集合 S 中的顶点是已经确定从源顶点到该顶点的最短路径的顶点，集合 Q 中的顶点是尚未确定从源顶点到该顶点的最短路径的顶点。
  • 每个顶点都有一个估计值，表示从源顶点到该顶点的可能最短路径长度，每次从集合 Q 中选出一个估计值最小的顶点，将其加入到集合 S 中，并对该顶点连接出去的顶点的估计值和前驱顶点进行松弛更新。
  • 按照上述步骤不断从集合 Q 中选取估计值最小的顶点到集合 S 中，直到所有的顶点都被加入到集合 S  中，此时通过各个顶点的估计值就可以得知源顶点到该顶点的最短路径长度，通过各个顶点的前驱顶点就可以得知最短路径的走向。

以下是Dijkstra算法的动图演示：

以下是《算法导论》中Dijkstra算法的图解：

Dijkstra算法的实现：

  • 使用一个 dist 数组来记录从源顶点到各个顶点的最短路径长度估计值，初始时将源顶点的估计值设置为权值的缺省值（比如int就是0），表示从源顶点到源顶点的路径长度为0，将其余顶点的估计值设置为MAX_W，表示从源顶点暂时无法到达其他顶点。
  • 使用一个 pPath 数组来记录到达各个顶点路径的前驱顶点，初始时将各个顶点的前驱顶点初始化为-1，表示各个顶点暂时只能自己到达自己，没有前驱顶点。
  • 使用一个 bool 数组来记录各个顶点是否在 S 集合中，初始时所有顶点均不在 S 集合，表示各个顶点都还没有确定最短路径。
  • 每次从 Q 集合中选出一个估计值最小的顶点 u ，将其加入到 S 集合，并对顶点 u 连接出去的各个顶点 v 进行松弛更新，如果能够将顶点 v 更新出更小的估计值，则更新其估计值，并将被更新的顶点 v 的前驱顶点改为顶点 u ，因为从顶点 u 到顶点 v 能够得到更小的估计值，所以在当前看来（后续可能还会更新）到达顶点 v 的最短路径的前驱顶点就应该是顶点 u ，如果不能将顶点 v 更新出更小的估计值，则维持原样。
  • 当所有的顶点都加入集合 S 后，dist 数组中存储的就是从源顶点到各个顶点的最短路径长度，pPath 数组中存储的就是从源顶点到各个顶点的最短路径的前驱顶点，通过不断查找各个顶点的前驱顶点，最终就能得到从源顶点到各个顶点的最短路径。

代码实现

下面是代码实现：

  1. #include <vector>
  2. #include <iostream>
  3. #include <string>
  4. #include <queue>
  5. #include <map>
  6. #include <set>
  7. #include <functional>
  8. using namespace std;
  9.  
  10. namespace Matrix // 临接矩阵
  11. {
  12. 	template<class V, class W, W MAX_W = INT_MAX, bool Direction = false>
  13. 	class Graph //Vertex顶点，Weight权值，MAX_W不存在边的标识值 ，Direction有向无向
  14. 	{
  15. 	private:
  16. 		vector<V> _vertexs; // 顶点集合，保存已找到的最短路的顶点，顶点所在位置的下标作为该顶点的编号
  17. 		map<V, size_t> _vIndexMap; // 顶点映射下标
  18. 		vector<vector<W>> _matrix; // 存储边集合的矩阵，_matrix[i][j]表示编号为i和j的两个顶点之间的关系
  19.  
  20. 	public:
  21. 		// 迪杰斯特拉算法，使用前提：图中所有边的权值非负。
  22. 		// 顶点个数是N  -> 时间复杂度：O（N^2）空间复杂度：O（N）
  23. 		void Dijkstra(const V& src, vector<W>& dist, vector<int>& pPath)
  24. 		{
  25. 			size_t n = _vertexs.size();
  26. 			size_t srci = GetVertexIndex(src); // 获取源顶点的下标
  27. 			dist.resize(n, MAX_W); // 各个顶点的估计值初始化为MAX_W
  28. 			pPath.resize(n, -1);  // 各个顶点的前驱顶点初始化为-1
  29.  
  30. 			dist[srci] = 0; // 源顶点的估计值
  31. 			pPath[srci] = srci;
  32. 			vector<bool> S(n, false); // 已经确定最短路径的顶点集合
  33. 			for (size_t j = 0; j < n; ++j) // 将Q集合中的n个顶点全部加入到S集合
  34. 			{
  35. 				int u = 0; // 记录下一个选出来的顶点
  36. 				W min = MAX_W; // 最小估计值
  37. 				for (size_t i = 0; i < n; ++i) // 选最短路径顶点且不在S更新其他路径
  38. 				{
  39. 					if (S[i] == false && dist[i] < min)
  40. 					{
  41. 						u = i;
  42. 						min = dist[i];
  43. 					}
  44. 				}
  45. 				S[u] = true; // 将选出的顶点加入到S集合
  46. 				for (size_t v = 0; v < n; ++v) // 松弛更新u连接顶点v (srci->u) + (u->v) < srci->v 更新
  47. 				{
  48. 					if (S[v] == false && _matrix[u][v] != MAX_W && dist[u] + _matrix[u][v] < dist[v])
  49. 					{
  50. 						dist[v] = dist[u] + _matrix[u][v]; // 松弛更新出更小的路径权值
  51. 						pPath[v] = u; // 更新路径的前驱顶点
  52. 					}
  53. 				}
  54. 			}
  55. 		}
  56.  
  57. 		// 打印最短路径及路径权值
  58. 		void PrintShortPath(const V& src, const vector<W>& dist, const vector<int>& pPath)
  59. 		{
  60. 			size_t srci = GetVertexIndex(src); // 获取源顶点的下标
  61. 			size_t n = _vertexs.size();
  62. 			for (size_t i = 0; i < n; ++i)
  63. 			{
  64. 				if (i != srci)
  65. 				{
  66. 					vector<int> path; // 找出i顶点的路径
  67. 					size_t parenti = i;
  68. 					while (parenti != srci)
  69. 					{
  70. 						path.push_back(parenti);
  71. 						parenti = pPath[parenti];
  72. 					}
  73. 					path.push_back(srci);
  74. 					reverse(path.begin(), path.end()); // 逆置
  75.  
  76. 					for (auto index : path)
  77. 					{
  78. 						cout << _vertexs[index] << "->";
  79. 					}
  80. 					cout << "权值和：" << dist[i] << endl;
  81. 				}
  82. 			}
  83. 		}
  84.     };
  85.  
  86.     void TestGraphDijkstra()
  87. 	{
  88. 		const char* str = "syztx";
  89. 		Graph<char, int, INT_MAX, true> g(str, strlen(str));
  90. 		g.AddEdge('s', 't', 10);
  91. 		g.AddEdge('s', 'y', 5);
  92. 		g.AddEdge('y', 't', 3);
  93. 		g.AddEdge('y', 'x', 9);
  94. 		g.AddEdge('y', 'z', 2);
  95. 		g.AddEdge('z', 's', 7);
  96. 		g.AddEdge('z', 'x', 6);
  97. 		g.AddEdge('t', 'y', 2);
  98. 		g.AddEdge('t', 'x', 1);
  99. 		g.AddEdge('x', 'z', 4);
  100.  
  101. 		vector<int> dist;
  102. 		vector<int> parentpath;
  103. 		g.Dijkstra('s', dist, parentpath);
  104. 		g.PrintShortPath('s', dist, parentpath);
  105.  
  106. 		// 图中带有负权路径时，贪心策略则失效了。
  107. 		// 测试结果可以看到s->t->y之间的最短路径没更新出来
  108. 		//const char* str = "sytx";
  109. 		//Graph<char, int, INT_MAX, true> g(str, strlen(str));
  110. 		//g.AddEdge('s', 't', 10);
  111. 		//g.AddEdge('s', 'y', 5);
  112. 		//g.AddEdge('t', 'y', -7);
  113. 		//g.AddEdge('y', 'x', 3);
  114. 		//vector<int> dist;
  115. 		//vector<int> parentPath;
  116. 		//g.Dijkstra('s', dist, parentPath);
  117. 		//g.PrintShortPath('s', dist, parentPath);
  118.  
  119. 		//const char* str = "syztx";
  120. 		//Graph<char, int, INT_MAX, true> g(str, strlen(str));
  121. 		//g.AddEdge('s', 't', 6);
  122. 		//g.AddEdge('s', 'y', 7);
  123. 		//g.AddEdge('y', 'z', 9);
  124. 		//g.AddEdge('y', 'x', -3);
  125. 		//g.AddEdge('z', 's', 2);
  126. 		//g.AddEdge('z', 'x', 7);
  127. 		//g.AddEdge('t', 'x', 5);
  128. 		//g.AddEdge('t', 'y', 8);
  129. 		//g.AddEdge('t', 'z', -4);
  130. 		//g.AddEdge('x', 't', -2);
  131. 		//vector<int> dist;
  132. 		//vector<int> parentPath;
  133. 		//g.Dijkstra('s', dist, parentPath);
  134. 		//g.PrintShortPath('s', dist, parentPath);
  135. 	}
  136. }

  • 为了方便观察，可以在类中增加一个 PrintShortPath接口，用于根据 dist 和  pPath 数组来打印最短路径及路径权值。
  • 对于从源顶点 s 到目标顶点 j 的最短路径来说，如果最短路径经过了顶点 i ，那么最短路径中从源顶点 s 到顶点 i 的这条子路径一定是源顶点 s 到顶点 i 的最短路径，因此可以通过存储前驱顶点的方式来表示从源顶点到各个顶点的最短路径。
  • Dijkstra算法每次需要选出一个顶点，并对其连接出去的顶点进行松弛更新，因此其时间复杂度：O（N^2）空间复杂度：O（N）

Dijkstra算法原理：

  • Dijkstra算法每次从集合 Q 中选出一个估计值最小的顶点 u ，将该顶点加入到集合 S 中，表示确定了从源顶点到顶点 u 的最短路径。
  • 因为图中所有边的权值非负（使用Dijkstra算法的前提），所以对于估计值最小的顶点 u 来说，其估计值不可能再被其他比它估计值更大的顶点松弛更新得更小，因此顶点 u 的最短路径就是当前的估计值。
  • 而对于集合 Q 中的其他顶点来说，这些顶点的估计值比顶点 u 的估计值大，因此顶点 u 可能将它们的估计值松弛更新得更小，所以顶点 u 在加入集合 S 后还需要尝试对其连接出去的顶点进行松弛更新。

5.2 Bellman-Ford算法_单源最短路径

基本思想

Bellman-Ford（贝尔曼-福特算法）算法的基本思想如下：

  • Bellman-Ford算法本质是暴力求解，对于从源顶点 s 到目标顶点 j 的路径来说，如果存在从源顶点 s 到顶点 i 的路径，还存在一条从顶点 i 到顶点 j 的边，并且其权值之和小于当前从源顶点 s 到目标顶点 j 的路径长度，则可以对顶点 j 的估计值和前驱顶点进行松弛更新。
  • Bellman-Ford算法根据路径的终边来进行松弛更新，但是仅对图中的边进行一次遍历可能并不能正确更新出最短路径，最坏的情况下需要对图中的边进行 n − 1 轮遍历（ n 表示图中的顶点个数）。

Bellman-Ford算法的实现：

  • 使用一个 dist 数组来记录从源顶点到各个顶点的最短路径长度估计值，初始时将源顶点的估计值设置为权值的缺省值（比如int就是0），表示从源顶点到源顶点的路径长度为0，将其余顶点的估计值设置为MAX_W，表示从源顶点暂时无法到达其他顶点。
  • 使用一个 pPath 数组来记录到达各个顶点路径的前驱顶点，初始时将各个顶点的前驱顶点初始化为-1，表示各个顶点暂时只能自己到达自己，没有前驱顶点。
  • 对图中的边进行 n − 1 轮遍历，对于 i −> j 的边来说，如果存在 s −> i 的路径，并且 s −> i 的路径权值与边 i −> j 的权值之和小于当前 s −> j 的路径长度，则将顶点 j 的估计值进行更新，并将顶点 j 的前驱顶点改为顶点 i ，因为 i −> j 是图中的一条直接相连的边，在这条路径中顶点 j 的上一个顶点就是顶点 i 。
  • 再对图中的边进行一次遍历，尝试进行松弛更新，如果还能更新则说明图中带有负权回路，无法找到最短路径。

代码如下：

代码实现

  1. namespace Matrix // 临接矩阵
  2. {
  3. 	template<class V, class W, W MAX_W = INT_MAX, bool Direction = false>
  4. 	class Graph //Vertex顶点，Weight权值，MAX_W不存在边的标识值 ，Direction有向无向
  5. 	{
  6. 	private:
  7. 		vector<V> _vertexs; // 顶点集合，顶点所在位置的下标作为该顶点的编号
  8. 		map<V, size_t> _vIndexMap; // 顶点映射下标
  9. 		vector<vector<W>> _matrix; // 存储边集合的矩阵，_matrix[i][j]表示编号为i和j的两个顶点之间的关系
  10.  
  11. 	public:
  12. 		// 贝尔曼-福特算法，可以解决图中边的权值为负，但不能解决带负权回路
  13. 		// 时间复杂度：O(N^3) 空间复杂度：O（N）
  14. 		bool BellmanFord(const V& src, vector<W>& dist, vector<int>& pPath)
  15. 		{
  16. 			size_t n = _vertexs.size();
  17. 			size_t srci = GetVertexIndex(src); // 获取源顶点的下标
  18. 			dist.resize(n, MAX_W); // dist 记录srci - 其他顶点最短路径权值数组，初始化为MAX_W
  19. 			pPath.resize(n, -1); // pPath 记录srci - 其他顶点最短路径父顶点数组，初始化为-1
  20. 			dist[srci] = W(); // 先更新srci->srci为缺省值
  21.  
  22. 			for (size_t k = 0; k < n - 1; ++k) // 总体最多更新n - 1轮
  23. 			{
  24. 				bool update = false; // 记录本轮是否更新过
  25. 				cout << "更新第:" << k << "轮" << endl;
  26. 				for (size_t i = 0; i < n; ++i)
  27. 				{
  28. 					for (size_t j = 0; j < n; ++j) // srci -> i + i ->j
  29. 					{
  30. 						if (_matrix[i][j] != MAX_W && dist[i] + _matrix[i][j] < dist[j])
  31. 						{
  32. 							cout << _vertexs[i] << "->" << _vertexs[j] << ":" << _matrix[i][j] << endl;
  33. 							dist[j] = dist[i] + _matrix[i][j]; // 松弛更新出更小的路径权值
  34. 							pPath[j] = i; // 更新路径的前驱顶点
  35. 							update = true;
  36. 						}
  37. 					}
  38. 				}
  39. 				if (update == false)
  40. 					break; // 如果这个轮次中没有更新出更短路径，那么后续轮次就不需要再走了
  41. 			}
  42.  
  43. 			for (size_t i = 0; i < n; ++i) // 还能更新就是带负权回路
  44. 			{
  45. 				for (size_t j = 0; j < n; ++j) // srci -> i + i ->j 
  46. 				{
  47. 					if (_matrix[i][j] != MAX_W && dist[i] + _matrix[i][j] < dist[j])
  48. 					{
  49. 						return false; // 带有负权回路的图无法求出最短路径
  50. 					}
  51. 				}
  52. 			}
  53. 			return true;
  54. 		}
  55.     };
  56.  
  57. 	void TestGraphBellmanFord()
  58. 	{
  59. 		//const char* str = "syztx";
  60. 		//Graph<char, int, INT_MAX, true> g(str, strlen(str));
  61. 		//g.AddEdge('s', 't', 6);
  62. 		//g.AddEdge('s', 'y', 7);
  63. 		//g.AddEdge('y', 'z', 9);
  64. 		//g.AddEdge('y', 'x', -3);
  65. 		//g.AddEdge('z', 's', 2);
  66. 		//g.AddEdge('z', 'x', 7);
  67. 		//g.AddEdge('t', 'x', 5);
  68. 		//g.AddEdge('t', 'y', 8);
  69. 		//g.AddEdge('t', 'z', -4);
  70. 		//g.AddEdge('x', 't', -2);
  71. 		//vector<int> dist;
  72. 		//vector<int> parentPath;
  73. 		//g.BellmanFord('s', dist, parentPath);
  74. 		//g.PrintShortPath('s', dist, parentPath);
  75.  
  76. 		const char* str = "syztx";
  77. 		Graph<char, int, INT_MAX, true> g(str, strlen(str));
  78. 		g.AddEdge('s', 't', 6);
  79. 		g.AddEdge('s', 'y', 7);
  80. 		g.AddEdge('y', 'z', 9);
  81. 		g.AddEdge('y', 'x', -3);
  82. 		//g.AddEdge('y', 's', 1); // 新增
  83. 		g.AddEdge('z', 's', 2);
  84. 		g.AddEdge('z', 'x', 7);
  85. 		g.AddEdge('t', 'x', 5);
  86. 		g.AddEdge('t', 'y', 8);
  87. 		//g.AddEdge('t', 'y', -8); // 更改 8 -> -8
  88.  
  89. 		g.AddEdge('t', 'z', -4);
  90. 		g.AddEdge('x', 't', -2);
  91. 		vector<int> dist;
  92. 		vector<int> parentPath;
  93. 		if (g.BellmanFord('s', dist, parentPath))
  94. 			g.PrintShortPath('s', dist, parentPath);
  95. 		else
  96. 			cout << "带负权回路" << endl;
  97. 	}
  98. }

  • Bellman-Ford算法是暴力求解，可以解决带有负权边的单源最短路径问题。
  • 负权回路指的是在图中形成回路的各个边的权值之和为负数，路径每绕一圈回路其权值都会减少，导致无法找到最短路径，由于最多需要进行 n − 1 轮松弛更新，因此可以在 n − 1 轮松弛更新后再进行一轮松弛更新，如果还能进行更新则说明带有负权回路。
  • Bellman-Ford算法需要对图中的边进行 n 轮遍历，因此其时间复杂度是 O ( N × E ) ，由于这里是用邻接矩阵实现的，遍历图中的所有边的时间复杂度是O(N^2)，所以上述代码的时间复杂度是O（N^2），空间复杂度是O（N）。

为什么最多进行 n − 1 轮松弛更新？

从一个顶点到另一个顶点的最短路径中不能包含回路：

  • 如果形成回路的各个边的权值之和为负数，则该回路为负权回路，找不到最短路径。
  • 如果形成回路的各个边的权值之和为非负数，则多走这个回路是“徒劳”的，可能会使得路径长度变长。

        在每一轮松弛过程中，后面路径的更新可能会影响到前面已经更新过的路径，比如使得前面已经更新过的路径的长度可以变得更短，或者使得某些源顶点之前不可达的顶点变得可达，但每一轮松弛至少能确定最短路径中的一条边，如果图中有 n 个顶点，那么两个顶点之间的最短路径最多有 n - 1 条边，因此最多需要进行 n - 1 次松弛更新。

        例如下图中，顶点A，B，C，D，E的下标分别是0、1、2、3、4，现在要计算以顶点 E 为源顶点的单源最短路径。

        对于上述图来说，Bellman-Ford算法在第一轮松弛的时候只能更新出 E -> D 这条边，在第二轮的时候只能更新出 D -> C，以此类推，最终就会进行4轮松弛更新（建议通过代码调试观察）。

  • 由于只有当前轮次进行过更新，才有可能会影响其他路径，因此在代码中使用 update 标记每轮松弛算法是否进行过更新，如果没有进行过更新，则无需进行后面轮次的更新。
  • Bellman-Ford算法还有一个优化方案叫做SPFA（Shortest Path Faster Algorithm），其用一个队列来维护可能需要松弛更新的顶点，避免了不必要的冗余计算，大家可以自行了解。

5.3 Floyd-Warshall算法_多源最短路径

基本思想

Floyd-Warshall（弗洛伊德算法）算法的基本思想如下：

        Floyd-Warshall算法解决的是任意两点间的最短路径的算法，其考虑的是路径的中间顶点，对于从顶点 i 到顶点 j 的路径来说，如果存在从顶点 i 到顶点 k 的路径，还存在从顶点 k 到顶点 j 的路径，并且这两条路径的权值之和小于当前从顶点 i 到顶点 j 的路径长度，则可以对顶点 j 的估计值和前驱顶点进行松弛更新。

        Floyd-Warshall算法本质是一个简单的动态规划，就是判断从顶点 i 到顶点 j 的这条路径是否经过顶点 k，如果经过顶点 k 可以让这条路径的权值变得更小，则经过，否则则不经过。

Floyd-Warshall算法的实现：

  • 使用一个 vvDist 二维数组来记录从各个源顶点到各个顶点的最短路径长度的估计值，vvDist[i][j] 表示从顶点 i 到顶点 j 的最短路径长度的估计值，初始时将二维数组中的值全部初始化为MAX_W，表示各个顶点之间暂时无法互通。
  • 使用一个 vvpPath 二维数组来记录从各个源顶点到达各个顶点路径的前驱顶点，初始时将二维数组中的值全部初始化为-1，表示各个顶点暂时只能自己到自己，没有前驱顶点。
  • 根据邻接矩阵对  vvDist 和 vvpPath 进行初始化，如果从顶点 i 到顶点 j 有直接相连的边，则将 vvDist[i][j] 初始化为这条边的权值，并将vvpPath 初始化为 i，表示在 i −> j 这条路径中顶点 j 前驱顶点是 i ，将 vvDist[i][i] 的值设置为权值的缺省值（比如int就是0），表示自己到自己的路径长度为0。
  • 依次取各个顶点 k 作为 i −> j 路径的中间顶点，如果同时存在 i −> k 的路径和 k −> j 的路径，并且这两条路径的权值之和小于当前 i −> j 路径的权值，则更新 vvDist[i][j] 的值，并将vvpPath 的值更新为 vvpPath 的值。

代码实现

代码如下：

  1. namespace Matrix // 临接矩阵
  2. {
  3. 	template<class V, class W, W MAX_W = INT_MAX, bool Direction = false>
  4. 	class Graph //Vertex顶点，Weight权值，MAX_W不存在边的标识值 ，Direction有向无向
  5. 	{
  6. 	private:
  7. 		vector<V> _vertexs; // 顶点集合，顶点所在位置的下标作为该顶点的编号
  8. 		map<V, size_t> _vIndexMap; // 顶点映射下标
  9. 		vector<vector<W>> _matrix; // 存储边集合的矩阵，_matrix[i][j]表示编号为i和j的两个顶点之间的关系
  10.  
  11. 	public:
  12. 		//获取多源最短路径（弗洛伊德算法）
  13. 		void FloydWarshall(vector<vector<W>>& vvDist, vector<vector<int>>& vvpPath)
  14. 		{
  15. 			size_t n = _vertexs.size();
  16. 			vvDist.resize(n, vector<W>(n, MAX_W)); // 任意两个顶点直接的路径权值初始化为MAX_W
  17. 			vvpPath.resize(n, vector<int>(n, -1)); // 各个顶点的前驱顶点初始化为-1
  18.  
  19. 			for (size_t i = 0; i < n; ++i) // 根据邻接矩阵初始化直接相连的顶点
  20. 			{
  21. 				for (size_t j = 0; j < n; ++j)
  22. 				{
  23. 					if (_matrix[i][j] != MAX_W) // i->j有边
  24. 					{
  25. 						vvDist[i][j] = _matrix[i][j]; // i->j的路径权值
  26. 						vvpPath[i][j] = i; // i->j路径的前驱顶点为i
  27. 					}
  28. 					if (i == j) // i->i
  29. 					{
  30. 						vvDist[i][j] = W(); // i->i的路径权值设置为权值的缺省值
  31. 					}
  32. 				}
  33. 			}
  34.  
  35. 			// 最短路径的更新i-> {其他顶点} ->j
  36. 			for (size_t k = 0; k < n; ++k) // 依次取各个顶点作为i->j路径的中间顶点
  37. 			{
  38. 				for (size_t i = 0; i < n; ++i)
  39. 				{
  40. 					for (size_t j = 0; j < n; ++j)
  41. 					{
  42. 						// k 作为的中间点尝试去更新i->j的路径
  43. 						if (vvDist[i][k] != MAX_W && vvDist[k][j] != MAX_W
  44. 							&& vvDist[i][k] + vvDist[k][j] < vvDist[i][j])
  45. 							// 存在i->k和k->j的路径，并且这两条路径的权值之和小于当前i->j路径的权值
  46. 						{
  47. 							vvDist[i][j] = vvDist[i][k] + vvDist[k][j]; // 松弛更新出更小的路径权值
  48.  
  49. 							// 找跟j相连的上一个邻接顶点
  50. 							// 如果k->j 直接相连，上一个点就k，vvpPath[k][j]存就是k
  51. 							// 如果k->j 没有直接相连，k->...->x->j，vvpPath[k][j]存就是x
  52. 							vvpPath[i][j] = vvpPath[k][j]; // 更小路径的前驱顶点
  53. 						}
  54. 					}
  55. 				}
  56.  
  57. 			//	for (size_t i = 0; i < n; ++i) // 打印权值和路径矩阵观察数据
  58. 			//	{
  59. 			//		for (size_t j = 0; j < n; ++j)
  60. 			//		{
  61. 			//			if (vvDist[i][j] == MAX_W)
  62. 			//				printf("%3c", '*');
  63. 			//			else
  64. 			//				printf("%3d", vvDist[i][j]);
  65. 			//		}
  66. 			//		cout << endl;
  67. 			//	}
  68. 			//	cout << endl;
  69.  
  70. 			//	for (size_t i = 0; i < n; ++i)
  71. 			//	{
  72. 			//		for (size_t j = 0; j < n; ++j)
  73. 			//		{
  74. 			//			printf("%3d", vvpPath[i][j]);
  75. 			//		}
  76. 			//		cout << endl;
  77. 			//	}
  78. 			//	cout << "=================================" << endl;
  79. 			}
  80. 		}
  81.     };
  82.  
  83. 	void TestFloydWarShall()
  84. 	{
  85. 		const char* str = "12345";
  86. 		Graph<char, int, INT_MAX, true> g(str, strlen(str));
  87. 		g.AddEdge('1', '2', 3);
  88. 		g.AddEdge('1', '3', 8);
  89. 		g.AddEdge('1', '5', -4);
  90. 		g.AddEdge('2', '4', 1);
  91. 		g.AddEdge('2', '5', 7);
  92. 		g.AddEdge('3', '2', 4);
  93. 		g.AddEdge('4', '1', 2);
  94. 		g.AddEdge('4', '3', -5);
  95. 		g.AddEdge('5', '4', 6);
  96. 		vector<vector<int>> vvDist;
  97. 		vector<vector<int>> vvParentPath;
  98. 		g.FloydWarshall(vvDist, vvParentPath);
  99.  
  100. 		// 打印任意两点之间的最短路径
  101. 		for (size_t i = 0; i < strlen(str); ++i)
  102. 		{
  103. 			g.PrintShortPath(str[i], vvDist[i], vvParentPath[i]);
  104. 			cout << endl;
  105. 		}
  106. 	}
  107. }

本篇完。

下一篇是其它高阶数据结构④_LRU_Cache（概念+实现OJ）

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/626258
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号