多源最短路求解的是图中的任意两个节点之间的最短路。
前文我们已经讲过单源最短路，我们完全可以做n次单源最短路算法，求出任意两节点的最短距离。最快的堆优化版的 dijkstra 算法的时间复杂度为o（m * logm），枚举n次时间复杂度变为o（n * m * logm）。
但是我们下文介绍的基于动态规划实现的Floyd算法中阶段性求解的方法才是多源最短路中最重要的。
Floyd算法
Floyd算法的本质是动态规划，也叫做插点法。通过不断在两点之间插入新的结点来更新最短路。
注意：Floyd算法适用于任何可以求解最短路的图，也就是说不能有负环。
1. 状态表示：f[k][i][j] ：表示仅仅经过【1 - k】这些结点时，i 到 j的最短路。
2. 状态转移方程：分析方法和背包问题相似。
f[k][i][j] = min(f[k-1][i][j], f[k-1][i][k] + f[k-1][k][j]) 3. 空间优化：由于是一层一层的遍历，所以我们可以去除第一维。
4. 填表顺序：填表的时候依赖的是 k - 1层的状态，所以一定要从 k 开始枚举。然后填表的时候正常从左到右，从上到下填。
5. 初始化：由于我们要做min操作，所以开始时要把所有的状态初始化成INF，从i 到 i 的最短路是零，所有还要把 f[i][i] 初始化成零（i从1 到 n）。
6. 最终结果：任意两个i j 就是两点间的最短路了。
B3647 【模板】Floyd - 洛谷
题目来源：洛谷
题目难度：★
【解题】：一道模板题啦~
🖥️code：
#include <iostream>
#include <cstring>
using namespace std;
const int N = 110, INF = 0x3f3f3f3f;
int n, m;
int f[N][N]; // dp表，同时也是邻接矩阵的存法
int main()
{
cin >> n >> m;
// 初始化
memset(f, 0x3f, sizeof f);
for(int i = 1; i <= n; i++) f[i][i] = 0;
for(int i = 1; i <= m; i++)
{
int a, b, c; cin >> a >> b >> c;
// 无向图存两遍，同时避免重边
f[a][b] = f[b][a] = min(f[a][b], c);
}
// 填表
for(int k = 1; k <= n; k++)
{
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= n; j++)
{
f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
}
}
}
// 最后f表就是任意两点的最短路
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= n; j++)
{
cout << f[i][j] << " ";
}
cout << endl;
}
return 0;
}P2910 [USACO08OPEN] Clear And Present Danger S - 洛谷
题目来源：洛谷
题目难度：★
【解题】：题目要求A1 A2 A3 --- An，让我们求最小的危险指数，从任意一点到另一点可以经过别的点，所以本题求得任意两点之间的最小危险指数，其实就是求最短路之和。
#include <iostream>
#include <cstring>
using namespace std;
const int N = 110, M = 1e4 + 10, INF = 0x3f3f3f3f;
int f[N][N];
int a[M];
int n, m;
int main()
{
cin >> n >> m;
for(int i = 1; i <= m; i++) cin >> a[i];
// init
// memset(f, 0x3f, sizeof f);
for(int i = 1; i <= n; i++) f[i][i] = 0;
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= n; j++)
{
cin >> f[i][j];
}
}
for(int k = 1; k <= n; k++)
for(int i = 1; i <= n; i++)
for(int j = 1; j <= n; j++)
f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
int ans = 0;
for(int i = 1; i < m; i++) ans += f[a[i]][a[i + 1]];
cout << ans << endl;
return 0;
} P1119 灾后重建 - 洛谷
题目来源：洛谷
题目难度：★★
【解题】：本题利用了Floyd算法阶段性解决最短路的特点。本题最关键的地方是村庄修复时间不下降和Q次询问的时候给的时间不下降，使我们可以阶段性插入节点。
当该村庄未修复完成时，它的道路不可走，我们就不插入这个节点，反之就插入这个节点。所以在不断插入的过程中就可以得出改时间的两点最短路。
🖥️code：
#include <iostream>
#include <cstring>
using namespace std;
const int N = 210, INF = 0x3f3f3f3f;
int n, m;
int t[N];
int f[N][N];
void floyd(int k)
{
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
}
int main()
{
cin >> n >> m;
for(int i = 0; i < n; i++) cin >> t[i];
memset(f, 0x3f, sizeof f);
for(int i = 0; i < n; i++) f[i][i] = 0;
for(int i = 1; i <= m; i++)
{
int a, b, c; cin >> a >> b >> c;
f[a][b] = f[b][a] = c;
}
int pos = 0;
int Q; cin >> Q;
while(Q--)
{
int a, b, c; cin >> a >> b >> c;
while(pos < n && t[pos] <= c) floyd(pos++);
if(t[a] > c || t[b] > c || f[a][b] == INF) cout << -1 << endl;
else cout << f[a][b] << endl;
}
return 0;
}P6175 无向图的最小环问题 - 洛谷
题目来源：洛谷
题目难度：★★
【解题】：其实这一题也是模板题。首先我们需要给这些环分类：按照环中节点编号的最大值分
类。在Floyd算法插入第k个结点之前，记录着从 1 - k-1 任意一个结点选择，任意两点的最短路。
此时我们强行插入第 k 个结点（注意我们并不关心i - j到底怎么走），就成了最编号为k的环，对这
些环取最小值就可以。
🖥️code：
#include <iostream>
#include <cstring>
using namespace std;
const int N = 110, M = 5e3 + 10, INF = 1e8;
int n, m;
int f[N][N];
int e[N][N];
int main()
{
cin >> n >> m;
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= n; j++)
{
f[i][j] = e[i][j] = INF;
}
}
for(int i = 1; i<= n; i++) f[i][i] = 0;
for(int i = 1; i <= m; i++)
{
int a, b, c; cin >> a >> b >> c;
f[a][b] = f[b][a] = min(f[a][b], c);
e[a][b] = e[b][a] = min(e[a][b], c);
}
// floyd
int ans = INF;
for(int k = 1; k <= n; k++)
{
// 此时f表的阶段为从1 - k-1 点中选出从i - j的最短路
// 将图按照最大结点编号划分，此时将k结点插入，就得到了最大编号为k的最小环
for(int i = 1; i < k; i++)
{
for(int j = i + 1; j < k; j++)
{
int t = f[i][j] + e[i][k] + e[k][j];
ans = min(ans, t);
}
}
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= n; j++)
{
f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
}
}
}
if(ans == INF) cout << "No solution." << endl;
else cout << ans << endl;
return 0;
}注意代码中的一个细节：
我么之前一直用0x3f3f3f3f代表无穷大的原因：
1、0x3f3f3f3f 大概是1e9级别的数，很大。
2、0x3f3f3f3f * 2 刚好不会超过 int 的范围。
这里我们求环的长度的时候加了三次，是有可能溢出的，根据C++的语法规则，溢出后变成负数，此时结果就被更新成负数，题目中m的范围是5×103，其实我们可以把INF定义为1e8就可以。
