1，Dijkstra 算法一次性求得起始顶点到所有其它顶点的最短路径，如果想要求解任意两个顶点之间的最短路径，可将图中顶点作为起始顶点执行 n 次 Dijkstra 算法就可以了；
2，可能解决方案：
1，算法执行结束后，i 到 j 最短路径值存储于 dist[i][j] 中。最短路径前驱结点存储于 path[N][N] 中；
2，这种方法比较土；
3，问题的提法：
1，已知一个各边权值均大于 0 的带权有向图，对每一对顶点 vi != vj，求出 vi 与 vj 之间的最短路径值以及最短路径上的顶点；
4，Floyd 算法核心：
1，定义一个 n 阶方阵序列：
其中：
2，怀疑当前两个顶点间路径不是最短路径，因此 Floyd 算法尝试通过其他顶点中转、直到找到一个中转点的中转路径最短；
5，n 阶方阵中元素的意义：
1，都是由邻接方阵中的权值推得的；
2，此算法是通过递推的方式得到两个顶点间最短路径的；
3，把所有的顶点的中转路径都推导完了，也就得到最小路径了；
4，后面方阵的推导，包含着前面方阵的信息，且每次推导都是最小，直到推导了全部顶点，得到最终最短路径；
6，Floyd 算法精髓：
7，Floyd 算法的实现：
1，初始化：
1，本质：使用邻接矩阵初始化 A(-1)；
2，A(0), ..., A(n-1) 矩阵推导：
1，本质：使用中转顶点逐步推导最短路径；
2，最外层是在说 A(k)矩阵的循环，循环推导完后，得到最短路径矩阵 A(n-1)，即为所求；
8，如何记录最短路径上的各个顶点？
1，定义辅助矩阵：
1，int path[N][N]; // 路径矩阵
1，path[i][j] 表示 i 到 j 的路径上所经过的第 1 个顶点；
2，初始化：path[i][j] = -1; or paht[i][j] = j;
1，有直接的连接则设置为 j，表示经过的第一个顶点为终值顶点 j；
2，没有连接的两个顶点设置为 -1；
3，修改：
1 if( (dist[i][k] + dist[k][j]) < dist[i][j] )
2 {
3 dist[i][j] = dist[i][k] + dist[k][j];
4 path[i][j] = paht[i][k];
5 }
1，if 条件为真，由 k 这个顶点中转可以得到一条更短路径，则由 i 到 j 这条路径上所经过的第一个顶点就是由 i 到 k 这条路径上经过的第一个顶点，因为由 k 中转了下；
2，路径矩阵示例：
1，由一个点的路径推至其它路径：
2，辅助矩阵和路径：
9，Floyd 最短路径算法实现：
1 /* floyd 每对结点之间最短路径算法，返回值为最短路径；核心为通过中转顶点寻找更短路径 */
2 SharedPointer< Array<int> > floyd(int x, int y, const E& LIMIT) // O(n*n*n)
3 {
4 LinkQueue<int> ret;
5
6 if( (0 <= x) && (x < vCount()) && (0 <= y) && (y < vCount()) ) //顶点编号要合理
7 {
8 DynamicArray< DynamicArray<E> > dist(vCount()); // 定义二维数组，N*N
9
10 DynamicArray< DynamicArray<int> > path(vCount()); // 最短路径的辅助数组
11
12 /* 定义二维数组 */
13 for(int k=0; k<vCount(); k++)
14 {
15 dist[k].resize(vCount());
16 path[k].resize(vCount());
17 }
18
19 /* 初始值设置 */
20 for(int i=0; i<vCount(); i++)
21 {
22 for(int j=0; j<vCount(); j++)
23 {
24 path[i][j] = -1; // i 和 j 是没有边的
25
26 dist[i][j] = isAdjacent(i, j) ? (path[i][j]=j, getEdge(i, j)) : LIMIT; // 邻接了就设置，利用了逗号表达式，逗号表达式第一个参数是设置顶点，第二个是设置权值
27 }
28 }
29
30 /* 推导最短路径矩阵 */
31 for(int k=0; k<vCount(); k++)
32 {
33 for(int i=0; i<vCount(); i++)
34 {
35 for(int j=0; j<vCount(); j++)
36 {
37 /* 推导规则，用中间顶点中转数据，看是否有最短路径值 */
38 if( (dist[i][k] + dist[k][j]) < dist[i][j] )
39 {
40 dist[i][j] = dist[i][k] + dist[k][j]; // 如果得到最短路径，认为其可能是最短路径，要更新其值
41
42 path[i][j] = path[i][k]; // 通过 k 顶点可以找到最小值，则这个顶点找到了
43 }
44 }
45 }
46 }
47
48 while( (x != -1) && (x != y) ) // 推导到终止顶点为止
49 {
50 ret.add(x); // 最短路径上的各个顶点加到返回值中
51
52 x = path[x][y]; // 递归的将 path[x][y] 上经过的第一个顶点放入 x 中，然后在下一个递推中从 x 出发再递归处其它顶点；
53 }
54
55 if( x != -1 )
56 {
57 ret.add(x); // 将最后的一个 x 加入返回值队列中，因为上面 x == y，终止了在返回队列中的加入，所以这里要加入
58 }
59 }
60 else
61 {
62 THROW_EXCEPTION(InvalidParameterException, "Index <x, y> is invalid ...");
63 }
64
65 /* 看看目标的两个最短值之间是否真的有最短路径 */
66 if( ret.length() < 2 )
67 {
68 THROW_EXCEPTION(ArithmeticException, "There is no path from x to y ...");
69 }
70
71 return toArray(ret);
72 }
10，小结：
1，Floyd 算法通过递推逐步求得所有顶点间的最短路径；
2，Floyd 算法的本质是通过中转顶点寻找更短的路径；
3，邻接矩阵是最短路径推导的起始矩阵；
4，路径矩阵记录了最短路径上的各个顶点；
原文地址：https://www.cnblogs.com/dishengAndziyu/p/10926671.html