浅谈 最短路

---

最短路问题（short-path problem）：最短路问题是图论研究中的一个经典算法问题，指在寻找图（由结点和路径组成的）中两结点之间的最短路径。算法具体的形式包括：

1.确定起点的最短路径问题 - 即已知起始结点，求最短路径的问题。

2.确定终点的最短路径问题 - 与确定起点的问题相反，该问题是已知终结结点，求最短路径的问题。在无向图中该问题与确定起点的问题完全等同，在有向图中该问题
等同于把所有路径方向反转的确定起点的问题。

3.确定起点终点的最短路径问题 - 即已知起点和终点，求两结点之间的最短路径。

4.全局最短路径问题 - 求图中所有的最短路径。

---

Floyd

part 1 算法本身

是一种基于动态规划的多源点最短路算法

dis[k][i][j]表示，从i到j一定经过<=k的点的最短路径

显然dis[0][i][j] = cost[i][j]

那么状态转移方程是？

其实也很容易，从k-1转移到k无非就是两种状态

1.不经过k点：dis[k - 1][i][j]

2.经过k点: dis[k - 1][i][k] + dis[k - 1][k][j]

好像区间dp哦

这个实现很简单吧（记得枚举k的循环放最外面

for(int k = 1; k <= n; k++)
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++) 
            dis[k][i][j] = min(dis[k - 1][i][j], dis[k - 1][i][k] + dis[k - 1][k][j]);

然后因为它是按阶段进行的，一定是上一个的值更新这一个，所以……第一维可以省略！然后我们就得到了最经典的Floyd算法

for(int k = 1; k <= n; k++)
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++) 
            dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);

Floyd算法输出路径和大多数算法一样采用记录前驱点的方式。我们定义:

pre[i][j]记录从i到j的最短路径中，j的前驱点。

递归还原路径即可。

模板代码

#include <cstdio> 
#include <cmath>
#include <cstring>
#include <algorithm>
using namespace std;

const int MAXN = 505;
int dis[MAXN][MAXN];
// 表示i到j的最短路
int pre[MAXN][MAXN];
// 表示i到j的最短路的j的前驱点
int s, t;
// 起点s，终点t

void floyd(int n) {
    // floyd算法
	for(int k = 1; k <= n; k++)
		for(int i = 1; i <= n; i++)
			for(int j = 1; j <= n; j++) {
   
				if(dis[i][j] > dis[i][k] + dis[k][j]) {
   
					dis[i][j] = dis[i][k] + dis[k][j];
					pre[i][j] = pre[k][j]; 
                    // 因为我们枚举的k是i到j的最短路的中转点集
                    // 所以i到j的最短路的j的前驱点其实就是k到j的最短路的j的前驱点
				}
			}
}

void print(int x) {
   
	if(pre[s][x] == 0) return ;
    // 边界条件：代表这已经是第一个点了（即它没有前驱点
	print(pre[s][x]);
    // 继续下一层
	printf(" %d", x);
}

int main() {
   
	memset(dis, 0x3f, sizeof dis); // 初始化，注意是0x3f，而不是0x3f3f3f3f
	int n, m;
	scanf ("%d %d", &n, &m);
    // 有n个店，m条边
	for(int i = 1; i <= m; i++) {
   
		int u, v, cost;
		scanf ("%d %d %d", &u, &v, &cost);
		dis[u][v] = cost;
        // 这里是一个有向图，所以单向存边
		pre[u][v] = u;
        // u到v的最短路目前一定是dis[u][v]
        // 所以可以直接初始化其前驱点为u，如果出现dis[u][k] + dis[k][v] < dis[u][v]的情况，将会在Floyd里处理
	}
	for(int i = 1; i <= n; i++) {
   
		dis[i][i