Floyd有向图最短路径解析

Floyd相比起Dijkstra，找任意两点最短距离更加方便。然而时间复杂度也会更高，为 $O(n^3)$。

下面用几张图描述算法实现具体过程

首先是一张有向网

初始化邻接矩阵 $A_{-1}$，不直接相连的两点之间权值无穷大，顶点到自己权重0。
初始化Path矩阵 $Path_{-1}$，每个值为-1。
-1代表两个点之间没有任何中间点。记住它是初始状态就行。

下面要引入中间结点v

对任一顶点对 $(i,j)$,若 $i\not=v$, $i\not=j$, $j\not=v$,若 $A[i][j]>A[i][v] +A[v][j]$,则将 $A[i][j]$更新为 $A[i][v] +A[v][j]$.

中间结点为0

要检测的顶点对有: {0,1}, {0, 2}, {0, 3}, {1, 0}, {1, 2}, {1, 3}, {2, 0}, {2, 1}, {2, 3}, {3, 0}, {3, 1}, {3, 2}. 因为要满足 $i\not=v$, $i\not=j$, $j\not=v$，所以这种情况只要检测 {1, 2}, {1, 3}, {2, 1}, {2, 3}, {3, 1}, {3, 2}这几种情况。由 $A_{-1}$和 $Path_{-1}$，代入 $A[i][j]>A[i][v] +A[v][j]$看这个不等式是否满足(v = 0)。
带入计算发现6个顶点对均不满足这个不等式，所以此轮不改变矩阵。 $A_0$和 $A_{-1}$一样， $Path_{0}$和 $Path_{-1}$一样。

中间结点为1

要检测的顶点对有: {0, 2}, {0, 3}, {2, 0}, {2, 3}, {3, 0}, {3, 2}. 由 $A_{0}$和 $Path_{0}$，代入 $A[i][j]>A[i][v] +A[v][j]$看这个不等式是否满足(v = 1)。 $A[0][2]>A[0][1] +A[1][2]$成立，故更新 $A[0][2]=A[0][1] +A[1][2]=5+4=9$. 同时 $Path_1$中 $A[0][2]$更新为1.

中间结点为2

要检测的顶点对有: {0, 1}, {0, 3}, {1, 0}, {1, 3}, {3, 0}, {3, 1}. 由 $A_{1}$和 $Path_{1}$，代入 $A[i][j]>A[i][v] +A[v][j]$看这个不等式是否满足(v = 2)。
更新：

中间结点为3

要检测的顶点对有: {0, 1}, {0, 2}, {1, 0}, {1, 2}, {2, 0}, {2, 1}. 由 $A_{2}$和 $Path_{2}$，代入 $A[i][j]>A[i][v] +A[v][j]$看这个不等式是否满足(v = 3)。
更新：

$A_3$和 $Path_3$为最终得到的矩阵，记作 $A$和 $Path$。

假设要计算1到0的最短路径

首先到 $Path$矩阵中去找 $Path[1][0] =3$, 发现要经过中间结点3。然后再去找 $Path[3][0] =2$，发现还要经过中间结点2，然后再去找 $Path[2][0] =-1$，说明顶点2到0不再有中间结点了。所以得出结论，顶点1到0的最短路径是 $1->3->2->0$。路径长度为6。

附代码

#include<iostream>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 1000;
int A[MAXN][MAXN];
int Path[MAXN][MAXN];
int length = 0;//记录两点间最短路径
void Floyd(int n) {
	for (int v = 0; v < n; ++v) {			//中间结点
		for (int i = 0; i < n; ++i) {		//A矩阵行
			for (int j = 0; j < n; ++j) {	//A矩阵列
				if (i != v && i != j && j != v && A[i][j] > A[i][v] + A[v][j]) {
					A[i][j] = A[i][v] + A[v][j];//更新A矩阵
					Path[i][j] = v;				//更新Path矩阵
				}
			}
		}
	}
}

void printPath(int from ,int to) {	
	if (Path[from][to] == -1) {
		cout << '<' << from << ',' << to << "> ";
		length += A[from][to];
	}	
	else {
		int mid = Path[from][to];//中间节点
		printPath(from, mid);
		printPath(mid, to);
	}
	
}
void init(int n,int m) {
	//初始化A和Path
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < n; ++j) {
			Path[i][j] = -1;
			if (i == j)
				A[i][j] = 0;
			else
				A[i][j] = INF;
		}
	}
	//加边
	cout << "添加边：" << endl;
	int from, to, weight;
	for (int i = 0; i < m; ++i) {
		cin >> from >> to >> weight;
		A[from][to] = weight;
	}
}
int main() {
	int n, m;//顶点数，边数
	cout << "输入顶点数和边数" << endl;
	cin >> n >> m;
	init(n, m);
	Floyd(n);
	cout << "输入想求哪两个点之间的最短路径(按00退出)：" << endl;
	int from, to;
	cin >> from >> to;
	while (!(from == 0 && to == 0)) {
		cout << "这两点间路径：";
		printPath(from, to);
		cout << "这两点间的最短距离是：" << length << endl;
		length = 0;//全局变量清0
		cin >> from >> to;
	}
}

结果