理论

全源最短路算法

1. Floyd 算法，时间复杂度为 O(n³)
2. 跑 n 次 Bellman - Ford 算法，时间复杂度是 O(n²m)
3. 跑 n 次 Heap - Dijkstra 算法，时间复杂度是 O(nmlogm)
   第 3 种算法被 Johnson 做了改造，可以求解带负权边的全源最短路。

Johnson（约翰逊）算法
4. 新建一个虚拟源点 0，从该点向其他所有点连一条边权为 0 的边，再用spfa 算法求出从 0 号点到其他所有点的最短路 h(i)。
5. 将新图的边权改造为 w(u,v) + h(u) - h(v)，这样能确保边权非负。
6. 以每个点为起点，跑 n 轮 Heap - Dijkstra 算法，求出任意两点间最短路。

7. 以下是结合Johnson算法对这幅图的分析：
   1. 构建虚拟源点及初始操作
   图中节点0是Johnson算法里新添加的虚拟源点 ，从它向节点1、2、3、4分别连了边权为0的边（绿色边）。接下来要用SPFA算法求从0号虚拟源点到其他所有节点的最短路$h(i)$ 。比如从节点0到节点1的边权为0 ，如果不存在更短路径，$h(1)$ 初始就是0 ；从节点0到节点4边权为0 ，若没有其他路径干扰，$h(4)$ 也为0 ；从节点0到节点2边权为-5 ，0 ->3->2。图中绿色数字即为初始操作(SPFA)后虚拟节点到个其余各个点的距离。
   2. 边权改造
   根据Johnson算法，需要将图中各边的边权改造为$w(u,v)+h(u)-h(v)$ ，以此确保边权非负。例如，对于节点1到节点2这条边，原始边权$w(1,2)$ 为-1 ，$h(1)=0$ ，$h(2)=--5$ ，则新边权为$0+-1-(-5)=4$ 。途中红色数字为改造后的边权，黑色数字为改造前的边权。
   3. 计算全源最短路
   完成边权改造后，以每个点为起点，运行n轮Heap - Dijkstra算法（n为图中节点数，这里n = 4 ，不包含虚拟源点0 ），从而求出图中任意两点间的最短路。

各个最短路算法分析：

	BFS	Heap-Dijkstra	SPFA	Floyd	Johnson
最短路类型	最少步数	单源	单源	全源	全源
建图	邻接矩阵	邻接表	邻接表	邻接矩阵	邻接表
算法		贪心，松弛	贪心，松弛	插点法	贪心，松弛
优化	队列	优先队列	队列		优先队列
负边权		不能	能	能	能
判负环		不能	能	能	能
时间复杂度	O(n + m)	O(mlogm)	O(nm)	O(n³)	O(nmlogm)
图的大小	大/中 n=10⁷, m=10⁷	大/中 n=10⁶, m=10⁶	中/小 n=10³, m=10⁴	小 n=10²	中/小 n=10³, m=10³

例题

https://www.luogu.com.cn/problem/P5905

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int INF = 1e9;
// 定义边的结构体，包含目标节点 v 和边的权重 w
struct edge { int v, w; };
// 邻接表存储图，e[i] 存储从节点 i 出发的所有边
vector<edge> e[N];
// vis 数组用于标记节点是否在队列中，cnt 数组用于记录每个节点入队的次数
int vis[N], cnt[N];
// h 数组用于存储从虚拟源点到各节点的最短路，d 数组用于存储从某个源点到各节点的最短路
long long h[N], d[N];
int n, m;// 使用 SPFA 算法计算从虚拟源点 0 到其他所有节点的最短路
void spfa() {// 定义一个队列用于存储待处理的节点queue<int> q;// 初始化 h 数组为一个很大的值，memset(63) 相当于将每个元素初始化为一个较大的数memset(h, 63, sizeof h);memset(vis, false, sizeof vis);// 虚拟源点到自身的距离为 0h[0] = 0;// 标记虚拟源点在队列中vis[0] = 1;// 将虚拟源点加入队列q.push(0);while (q.size()) {int u = q.front();q.pop();// 标记该节点不在队列中vis[u] = 0;// 遍历从节点 u 出发的所有边for (auto ed : e[u]) {// 获取目标节点 v 和边的权重 wint v = ed.v, w = ed.w;// 如果通过节点 u 到达节点 v 的距离更短，则更新 h[v]if (h[v] > h[u] + w) {h[v] = h[u] + w;// 更新节点 v 的入队次数cnt[v] = cnt[u] + 1;// 如果某个节点入队次数超过 n 次，说明存在负环if (cnt[v] > n) {printf("-1\n");// 存在负环，程序退出exit(0);}// 如果节点 v 不在队列中，则将其加入队列if (!vis[v]) {q.push(v);vis[v] = 1;}}}}
}// 使用 Dijkstra 算法计算从源点 s 到其他所有节点的最短路
void dijkstra(int s) {// 定义一个优先队列，用于存储待处理的节点，按照距离从小到大排序priority_queue<pair<long long, int>> q;// 初始化 d 数组为无穷大for (int i = 1; i <= n; i++) {d[i] = INF;}// 初始化 vis 数组为 false，表示所有节点都未被处理memset(vis, false, sizeof vis);// 源点到自身的距离为 0d[s] = 0;// 将源点加入优先队列q.push({ 0,s });// 当优先队列不为空时进行处理while (q.size()) {// 取出队首节点int u = q.top().second;q.pop();// 如果该节点已经被处理过，则跳过if (vis[u]) {continue;}// 标记该节点已被处理vis[u] = 1;// 遍历从节点 u 出发的所有边for (auto ed : e[u]) {// 获取目标节点 v 和边的权重 wint v = ed.v;int w = ed.w;// 如果通过节点 u 到达节点 v 的距离更短，则更新 d[v]if (d[v] > d[u] + w) {d[v] = d[u] + w;// 如果节点 v 未被处理，则将其加入优先队列if (!vis[v]) {q.push({ -d[v],v });}}}}
}int main() {cin >> n >> m;// 输入每条边的信息，并将其加入邻接表for (int i = 0; i < m; i++) {int a, b, c;cin >> a >> b >> c;e[a].push_back({ b,c });}// 从虚拟源点 0 向其他所有节点添加一条边权为 0 的边for (int i = 1; i <= n; i++) {e[0].push_back({ i,0 });//加虚拟边}// 调用 SPFA 算法计算从虚拟源点到其他所有节点的最短路spfa();// 对图的边权进行重新计算，确保所有边权非负for (int u = 1; u <= n; u++) {for (auto& ed : e[u]) {ed.w += h[u] - h[ed.v];//构造新边}}// 以每个节点为源点，调用 Dijkstra 算法计算最短路for (int i = 1; i <= n; i++) {dijkstra(i);long long ans = 0;// 计算从源点 i 到其他所有节点的最短路的加权和for (int j = 1; j <= n; j++) {// 如果节点 j 不可达，则使用无穷大计算if (d[j] == INF) {ans += (long long)j * INF;}// 否则，使用实际距离计算else {ans += (long long)j * (d[j] + h[j] - h[i]);}}// 输出结果printf("%lld\n", ans);}return 0;
}