洛谷__P5905 【模板】全源最短路（Johnson）

题目链接：P5905 【模板】全源最短路（Johnson） - 洛谷

题目大意：

给定一个包含  个结点和  条带权边的有向图，求所有点对间的最短路径长度，

一条路径的长度定义为这条路径上所有边的权值和。

注意：

  1. 边权可能为负，且图中可能存在重边和自环；

  2. 部分数据卡  轮 SPFA 算法。

( 1≤n≤3×103,  1≤m≤6×103 )

Johnson算法：

整体思路就是对每个点跑一遍 Dijkstra ，

众所周知，Dijkstra 是不适用与存在负边权的图，

所以我们要先对每个边进行一遍预处理，使得每条边权都不为负数；

一种容易想到的方法是给所有边的边权同时加上一个正数  ，从而让所有边的边权均非负。

如果新图上起点到终点的最短路经过了  条边，则将最短路减去  即可得到实际最短路。

但这样的方法是错误的。参考下图：

 的最短路为 ，长度为 。

但假如我们把每条边的边权加上  呢？

新图上  的最短路为  ，已经不是实际的最短路了。

注：因为两条路径经过的边数不一样，加的值也不同，所以会导致这种错误

Johnson 算法则通过另外一种方法来给每条边重新标注边权。

我们新建一个虚拟节点(。从这个点向其他所有点连一条边权为  的边。

接下来用 spfa 算法求出从  号点到其他所有点的最短路，记为  。

假如存在一条路径从  点到  点，边权为  的边，则我们将该边的边权重新设置为 。

首先，从到的路径中随便取出一条：

s−>p1​−>p2​−>⋯−>pk​−>t

则这条路径的长度为：

简化后得到：

可以发现，不管走哪条路径，最后都是，而和又是不变的，所以最终得到的最短路径还是原来的最短路径。

证明新图对应每条边 wu,v+hu- hv>=0：

  1. 若0到v的最短路经过u，则有hv=hu+wu,v
  2. 若0到v的最短路没经过u，则有hv<=hu+wu,v

代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<vector>
#include<queue>
#include<deque>
#include<stack>
#include<set>
#include<map>
#include<unordered_set>
#include<unordered_map>
#include<bitset>
#include<tuple>
#define inf 1e9
#define int long long
#define endl '\n'
#define F first
#define S second
#define  mst(a,x) memset(a,x,sizeof (a))
using namespace std;
typedef pair<int, int> pii;

const int N = 6008, M = N << 1, mod = 998244353;

int n, m;
int h[N], ne[M], e[M], w[M], idx;
vector<int> dh(N, inf), dis(N, inf);
int cnt[N];

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

void spfa() {

    vector<bool> st(n + 1);
    queue<int> q;
    dh[0] = 0, st[0] = true;
    q.push(0);
    
    while (q.size()) {
        int u = q.front();
        q.pop();
        st[u] = false;
        
        for (int i = h[u]; ~i; i = ne[i]) {
            int j = e[i];
            if (dh[j] > dh[u] + w[i]) {
                dh[j] = dh[u] + w[i];
                cnt[j] = cnt[u] + 1;
                if (cnt[j] > n) {
                    cout << -1 << endl;
                    exit(0);
                }
                
                if (!st[j]) {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
        
    }
}

void dij(int x) {

    vector<bool> st(n + 1);
    priority_queue<pii, vector<pii>, greater<pii> > q;
    for (int i = 1; i <= n; i++) dis[i] = inf;
    
    dis[x] = 0;
    q.push({dis[x], x});
    
    while (q.size()) {
        auto[d, u] = q.top();
        q.pop();
        
        if (st[u]) continue;
        st[u] = true;
        
        for (int i = h[u]; ~i; i = ne[i]) {
            int j = e[i];
            if (dis[j] > d + w[i]) {
                dis[j] = d + w[i];
                q.push({dis[j], j});
            }
        }
    }
}

void solve() {

    mst(h, -1);
    cin >> n >> m;
    while (m--) {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }
    for (int i = 1; i <= n; i++) add(0, i, 0);
    
    spfa();
    
    for (int u = 1; u <= n; u++) {
        for (int i = h[u]; ~i; i = ne[i]) {
            int j = e[i];
            w[i] += dh[u] - dh[j];
        }
    }
    
    for (int i = 1; i <= n; i++) {
        dij(i);
        
        int res = 0;
        for (int j = 1; j <= n; j++) {
            if (dis[j] == inf) res += j * inf;
            else res += j * (dis[j] + dh[j] - dh[i]);
        }
        cout << res << endl;
    }
    
    
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);
    
    int T = 1;
// cin >> T;
    while (T--) solve();
    
    return 0;
}

 

posted @ 2025-11-21 13:51  wwjjw  阅读(20)  评论(0)    收藏  举报