P5905 【模板】Johnson 全源最短路（存在负边权的全源最短路）

题目传送门

题意： 给你一张图，可能存在负的边，如果存在负环则输出-1，否则按照题目要求输出 求和公式不会打 。

对于这个，判断是否存在负环跑spfa即可。如果不存在负环，我们可以用n遍spfa去处理这个问题，spfa的时间复杂度是O(kE),k是常数，最坏可以达到O（VE），V即顶点数，跑n遍那就是O(V²E),那有没有更加理想的算法呢？有！Johnson算法。

Johnson算法
在一个带负边权但无负环的图中，我们建立一个虚点，并且从这个虚点出发到每一个点都建立一条长度为0的有向边，以这个虚点为源点，跑一遍spfa，记录到每个点的最短路径为h[i],然后我们重新给原有的边赋值，w(u,v):=w(u,v)+h[u]-h[v];这样就可以做到所有边权均为非负。最后我们跑n遍Dijkstra，就做到了O(n*(n+m)*logm),每次都得到dis数组，如果源点i和目标点j之间连通，那么实际距离应该是dis[j]+h[j]-h[i]（因为之前我们给边重新赋值了，现在要退回）。

简略证明
证明1：重新赋值。
假设我们只有一条有向边，1->2,权值为-1，我们构建虚点之后，h[1]=0.h[2]=-1,w(1,2):=w(1,2)+h[1]-h[2]=0,其他情况亦然，这就能保证我们跑Dijkstra的正确性。

证明2：退回。
这也不难，因为之前我们重新赋值，假设有3个点，1->2->3，dis[1][3]=dis[1][2]’+dis[2][3]’,而我们之前有这样的操作dis[1][2]’=dis[1][2]+h[1]-h[2],dis[2][3]’=dis[2][3]+h[2]-h[3],这样加起来之后，dis[1][3]=dis[1][2]+dis[2][3]+h[1]-h[3],,所以我们最后对dis[1][3]+h[3]-h[1]就是正确的距离。

#include<bits/stdc++.h>
#define endl '\n'
#define null NULL
#define ls p<<1
#define rs p<<1|1
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define ll long long
#define int long long
#define vi vector<int>
#define mii map<int,int>
#define pii pair<int,int>
#define ull unsigned long long
#define all(x) x.begin(),x.end()
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define ct cerr<<"Time elapsed:"<<1.0*clock()/CLOCKS_PER_SEC<<"s.\n";
char *fs,*ft,buf[1<<20];
#define gc() (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<20,stdin),fs==ft))?0:*fs++;
inline int read(){int x=0,f=1;char ch=gc();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=gc();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=gc();}
return x*f;}
using namespace std;
const int N=1e4+5;
const int inf=0x7fffffff;
const int mod=998244353;
const double eps=1e-6;
int head[N],nxt[N],to[N],val[N],tot=0,n,m;
void add(int u,int v,int w)
{
    nxt[++tot]=head[u];
    to[tot]=v;
    val[tot]=w;
    head[u]=tot;
}
int dis[N],vis[N],cnt[N],h[N];
bool spfa()
{
    queue<int>q;
    for(int i=1;i<=n;i++)
    {
        h[i]=0,vis[i]=1;q.push(i);//判负环，把所有点加入队列更保险
    }
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=0;
        for(int i=head[u];i;i=nxt[i])
        {
            int v=to[i];
            if(h[u]+val[i]<h[v])
            {
                h[v]=h[u]+val[i];
                cnt[v]++;
                    if(cnt[v]>=n+1)
                        return false;//存在负环的条件
                if(!vis[v])
                {
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
    }
    return true;
}
void dij(int s)
{
    for(int i=1;i<=n;i++)
        dis[i]=1e9,vis[i]=0;
    priority_queue<pii >q;
    dis[s]=0;
    q.push(mp(-dis[s],s));
    while(!q.empty())
    {
        int u=q.top().se;
        q.pop();
        if(vis[u]==1)
            continue;
        vis[u]=1;
        for(int i=head[u];i;i=nxt[i])
        {
            int v=to[i];
            if(dis[u]+val[i]<dis[v])
            {
                dis[v]=dis[u]+val[i];
                q.push(mp(-dis[v],v));
            }
        }
    }
}
signed main()
{
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        int u,v,w;
        cin>>u>>v>>w;
        add(u,v,w);
    }
    for(int i=1;i<=n;i++)
        add(0,i,0);
    if(!spfa())
    {
        cout<<-1<<endl;
        return 0;
    }
    for(int i=1;i<=n;i++)
        for(int j=head[i];j;j=nxt[j])
            val[j]+=h[i]-h[to[j]];
    for(int i=1;i<=n;i++)
        cout<<h[i]<<endl;
    for(int i=1;i<=n;i++)
    {
        dij(i);
        int res=0;
        for(int j=1;j<=n;j++)
        {
            if(dis[j]==1e9)
                res+=j*1e9;
            else
                res+=j*(dis[j]+h[j]-h[i]);//回退成正确的距离。
        }
        cout<<res<<endl;
    }
}