Johnson

理论

全源最短路算法

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);
    // 虚拟源点到自身的距离为 0
    h[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 和边的权重 w
            int 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);
    // 源点到自身的距离为 0
    d[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 和边的权重 w
            int 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;
}