P5905 【模板】Johnson 全源最短路 （如何用Dijkstra跑带负权的图）

洛谷：全源最短路

具体思路和一些细节证明，周报里写的就挺不错的

一些个人理解补充在注释里：

#include<bits/stdc++.h>
#include<unordered_set>
#include<unordered_map>
#define mem(a,b) memset(a,b,sizeof a)
#define cinios (ios::sync_with_stdio(false),cin.tie(0),cout.tie(0))
#define cout_double(a) cout << setiosflags(ios::fixed) << setprecision(a)
#define sca scanf
#define pri printf
#define ul u << 1
#define ur u << 1 | 1
//#pragma GCC optimize(2)
using namespace std;

typedef long long ll;
typedef pair<int, int> PII;

const int N = 3010, M = 6010;
int INF = 0x3f3f3f3f, mod = 1e9 + 7;
ll LNF = 0x3f3f3f3f3f3f3f3f;
int n, m, k, T, S;
int h[N], e[M], ne[M], w[M], idx;
int dist[N], ds[N];
bool st[N];
int q[N], cnt[N];
struct edge
{
    int a, b, w;
}eg[M];
ll ans[N];

void add(int a, int b, int x) {
    e[idx] = b, ne[idx] = h[a], w[idx] = x, h[a] = idx++;
}

//边有负权，dijkstra算法不顶用怎么办？
//正常想法：找可以处理负权边的算法，比如Floyd、spfa、bellmen——ford
//但要知道，这些算法在最坏情况下的时间复杂度都是比 dj 要高的
//毒瘤题卡你时间怎么办？

//选择Johnson算法：对负权边进行一个预处理，全部转化成正权边，再用 dj 求解
//Johnson不是简单地每个边都加上相同的权值，让图中边全变为正（可证得是错的）
// 
// 它的方法是建立一个超级源点，跑一遍这个图(无负环)，得到每个点到超级源点的距离 ds
// 
// 之后图中任意一条边{a, b, w}就可以转化成{a, b, w + ds[a] - ds[b]}
// 由三角不等式（第一遍跑最短路时更新条件是{ds[b] > ds[a] + w}）可证得
// ds[b] <= ds[a] + w => w + ds[a] - ds[b] >= 0 所以所有的边都会大于等于0
// 
// 而重新标记后的图上，从 s 点到 t 点的一条路径 s -> p1 -> p2 -> ... -> pk -> t 的长度表达式如下：
//
// (w(s,p1) + hs - hp1) + (w(p1,p2) + hp1 - hp2) + ... + (w(pk,t) + hpk - ht)
// 
// 显然易看出，从 s 点到 t 点的一条路径长度为：原路径上全部 w 累加 + hs - ht（预处理的ds[s]和ds[t]）
// 
// 这就是Johnson的大致思路
// 

bool spfa() { //判一下是否有负权回路，有的话跑最短路肯定没意义
    int hh = 0, tt = 0;
    for (int i = 1; i <= n; i++)//全部点入队相当于建了超级源点
        q[tt++] = i, st[i] = true;

    while (hh != tt)//循环队列
    {
        int t = q[hh++];
        if (hh == N)hh = 0;

        st[t] = false;

        for (int i = h[t]; ~i; i = ne[i]) {
            int j = e[i];

            if (ds[j] > ds[t] + w[i]) {
                ds[j] = ds[t] + w[i];
                cnt[j] = cnt[t] + 1;

                //因为包括 0 号点
                if (cnt[j] > n)return true;//所以路径超过 n 条边肯定有负环
                
                if (!st[j]) {
                    st[j] = true;
                    q[tt++] = j;
                    if (tt == N)tt = 0;
                }
            }
        }
    }
    return false;
}

void dj(int s) {
    mem(st, 0);
    mem(dist, 0x3f);
    dist[s] = 0;

    priority_queue<PII, vector<PII>, greater<PII>> q;//堆优化
    q.push({ 0,s });

    while (q.size())
    {
        PII t = q.top();
        q.pop();

        int ver = t.second;
        if (st[ver])continue;
        st[ver] = true;

        for (int i = h[ver]; ~i; i = ne[i]) {
            int j = e[i];

            if (dist[j] > dist[ver] + w[i]) {
                dist[j] = dist[ver] + w[i];
                q.push({ dist[j],j });
            }
        }
    }
}

int main() {
    
    sca("%d%d", &n, &m);

    mem(h, -1);
    for (int i = 0; i < m; i++)
    {
        int a, b, x;
        sca("%d%d%d", &a, &b, &x);
        eg[i] = { a,b,x };
        add(a, b, x);
    }

    if (spfa())cout << -1;//负环
    else {
        mem(h, -1);//否则重建边
        idx = 0;

        for (int i = 0; i < m; i++) {
            int a = eg[i].a, b = eg[i].b;
            add(a, b, eg[i].w + ds[a] - ds[b]);//预处理边权，使全为正
        }
        
        for (int i = 1; i <= n; i++) {
            dj(i);//一个点跑一次
            for (int j = 1; j <= n; j++) {
                if (dist[j] == INF)dist[j] = 1e9;
                else dist[j] = dist[j] - ds[i] + ds[j];//减回来，找回原本的最短路

                if (i == j)continue;
                ans[i] += (ll)j * dist[j];//注意范围
            }
        }

        for (int i = 1; i <= n; i++)
            pri("%lld\n", ans[i]);
    }

    return 0;
}