P5905 【模板】Johnson 全源最短路+重载运算操作符

pace_the

已于 2022-10-17 18:22:00 修改

阅读量497

点赞数

文章标签： c++ 算法数据结构

于 2022-05-02 14:36:29 首次发布

本文链接：https://blog.youkuaiyun.com/ale_upcer/article/details/124540667

版权

题目描述

给定一个包含 nn 个结点和 mm 条带权边的有向图，求所有点对间的最短路径长度，一条路径的长度定义为这条路径上所有边的权值和。

注意：

边权可能为负，且图中可能存在重边和自环；
部分数据卡 nn 轮 SPFA 算法。

输入格式

第 11 行：22 个整数 n,mn,m，表示给定有向图的结点数量和有向边数量。

接下来 mm 行：每行 33 个整数 u,v,wu,v,w，表示有一条权值为 ww 的有向边从编号为 uu 的结点连向编号为 vv 的结点。

输出格式

若图中存在负环，输出仅一行 -1−1。

若图中不存在负环：

输出 nn 行：令 dis_{i,j}disi,j 为从 ii 到 jj 的最短路，在第 ii 行输出 \sum\limits_{j=1}^n j\times dis_{i,j}j=1∑nj×disi,j，注意这个结果可能超过 int 存储范围。

如果不存在从 ii 到 jj 的路径，则 dis_{i,j}=10^9disi,j=109；如果 i=ji=j，则 dis_{i,j}=0disi,j=0。

输入输出样例

输入 #1复制

输出 #1复制

输入 #2复制

输出 #2复制

-1

说明/提示

【样例解释】

左图为样例 11 给出的有向图，最短路构成的答案矩阵为：

0 4 11 8 11 
1000000000 0 7 4 7 
1000000000 -5 0 -3 0 
1000000000 -2 5 0 3 
1000000000 -1 4 1 0

右图为样例 22 给出的有向图，红色标注的边构成了负环，注意给出的图不一定连通。

【数据范围】

对于 100\%100% 的数据，1\leq n\leq 3\times 10^3,\ \ 1\leq m\leq 6\times 10^3,\ \ 1\leq u,v\leq n,\ \ -3\times 10^5\leq w\leq 3\times 10^51≤n≤3×103, 1≤m≤6×103, 1≤u,v≤n, −3×105≤w≤3×105。

对于 20\%20% 的数据，1\leq n\leq 1001≤n≤100，不存在负环（可用于验证 Floyd 正确性）

对于另外 20\%20% 的数据，w\ge 0w≥0（可用于验证 Dijkstra 正确性）

upd. 添加一组 Hack 数据：针对 SPFA 的 SLF 优化

分析：

floyd O(n^3)太慢，可以处理负权，但不能判断负权回路。

一次spfa最坏O(NM) N次是O(N^2M)不会比floyd好

dijkstra一次O((M+N)logN) N次也就是O(N(M+N)logN)能过，但不能处理负权和判负权回路，

先用spfa处理一次，新增一个点，到个点距离0，对这个点跑一次spfa，得到dis0【】，然后用这个距离数组处理边，得非负值，后抛弃这个点，再跑n次dijkstra，最后结果再对边处理回来就可以

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const ll Inf=0x3f3f3f3f3f3f3f3f;
ll n,m;
vector<pair<ll,ll>>v[3009];
vector<pair<ll,ll>>v2[3009];
ll dis0[3009];
ll vis0[3009];
//ll vis2[3009][3009];
ll vis2[3009];
ll cnt[3009];
ll dis[3009][3009];
struct node{
    ll order;
    ll d;
    bool operator <(const node& b)const{
        return d>b.d;
    }
};
ll spfa(){
    int i,j;
    for(i=1;i<=n;i++){
        v[0].emplace_back(i,0);
    }
    dis0[0]=0;
    queue<ll>q;
    vis0[0]=1;
    q.push(0);
    while(!q.empty()){
        ll cur=q.front();
        q.pop();
        vis0[cur]=0;
        cnt[cur]++;
        if(cnt[cur]>n){  //n+1个点，这里是n
            return -1;
        }
        for(i=0;i<(int)v[cur].size();i++){
            if(dis0[v[cur][i].first]>dis0[cur]+v[cur][i].second){
                dis0[v[cur][i].first]=dis0[cur]+v[cur][i].second;
                if(vis0[v[cur][i].first]==0){
                    q.push(v[cur][i].first);
                    vis0[v[cur][i].first]=1;
                }
            }
        }
    }
    return 1;
}
void dijkstra(ll s){  //这里不再处理新增的那个点
    memset(vis2,0,sizeof(vis2));
    priority_queue<node>q2;
    q2.push(node{s,0});
    dis[s][s]=0;
    ll i;
    while(!q2.empty()){
        node cur=q2.top();
        q2.pop();
        //if(vis2[s][cur.order]==1)continue;
        //vis2[s][cur.order]=1;
        if(vis2[cur.order]==1)continue;
        vis2[cur.order]=1;
        for(i=0;i<(ll)v2[cur.order].size();i++){
            if(dis[s][v2[cur.order][i].first]>dis[s][cur.order]+v2[cur.order][i].second){
                dis[s][v2[cur.order][i].first]=dis[s][cur.order]+v2[cur.order][i].second;
                q2.push(node{v2[cur.order][i].first,dis[s][cur.order]+v2[cur.order][i].second});
            }
        }
    }
    return ;
}
int main (){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin>>n>>m;
    ll i,j;
    for(i=1;i<=m;i++){
        ll x,y,w;
        cin>>x>>y>>w;
        if(x==y)continue;
        v[x].emplace_back(y,w);
    }
    memset(dis0,0x3f,sizeof(dis0));
    if(spfa()==-1){
        cout<<-1<<endl;
        return 0;
    }
    for(i=1;i<=n;i++){
        for(j=0;j<(int)v[i].size();j++){
            v2[i].emplace_back(v[i][j].first,v[i][j].second+dis0[i]-dis0[v[i][j].first]);
        }
    }
    memset(dis,0x3f,sizeof(dis));
    for(i=1;i<=n;i++){
        dijkstra(i);
    }
    for(i=1;i<=n;i++){
        ll res=0;
        for(j=1;j<=n;j++){
            if(i==j)continue;
            if(dis[i][j]==Inf)res+=j*1e9;
            else res+=j*(dis[i][j]-dis0[i]+dis0[j]);  //记得再处理回来
        }
        cout<<res<<endl;
    }
    return 0;
}