Johnson全源最短路径算法

算法目的

解决无负环图上任意两点间最短路径问题

算法介绍

Johson 算法通过一种方法来给每一条重新标注边权。我们新建一个虚拟节点，可编号为 0，设这个点连接其它所有点的边权为 0。接下来跑 Bellman-Ford 算法求出从0结点到其它所有点的最短路，记为 h[i]。那么就可用 h[i] 重新设置边的边权（如下）。接下来以每个点跑 n 轮 Dijkstra 算法即可求出任意两点间的最短路了。

假如存在一条从 u 到 v 的结点，边权为 w 的边，则我们将该边的边权重新设置为 $w+h[u]-h[v]$

优点

最显著的优点是快于其它最短路算法解决多源最短路问题，任意两点间的最短路可以枚举起点，跑 n 次 Bellman-Ford 算法解决，时间复杂度是 $O$($e\times$${\mathbf{v}}^2$)，也可以直接用 Floyd 算法解决，时间复杂度为 $O$(${\mathbf{v}}^3$)。我们知道堆优化的 Dijkstra 算法求最短路的时间复杂度比 Bellman-Ford 更优，如果枚举起点跑 n 次 Dijkstra 算法，就可以把时间复杂度降为 $O(veloge)$，但是 Dijkstra 算法不能解决带负边权的最短路，因此我们需要对原图的边进行预处理，确保所有边的边权均为非负，而 Johnson 算法的第一步就是对边进行预处理。

板子题目：P5905 【模板】全源最短路（Johnson)

参考代码

#include<stdio.h>
#include<queue>
#include<vector>
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string.h>
#include<stack>
#include<limits.h>
#include<string.h>
#include<math.h>
#define inf 500005
using namespace std;
int n,m;
typedef pair<long long,long long> pii;
long long dist[3005];
long long h[3005];
struct node{
	long long to;
	long long next;
	long long w;
}e[60005];
long long head[3005];
long long cnt[3005];
long long num;
queue<long long> q;
int flag[3005];
int spfa(){
	for(int i=1;i<=n;i++){
		q.push(i);
		flag[i]=1;
	}
	while(q.empty()==0){
		long long t=q.front();
		q.pop();
		flag[t]=0;
		for(int i=head[t];i!=0;i=e[i].next){
			if(dist[e[i].to]>dist[t]+e[i].w){
				dist[e[i].to]=dist[t]+e[i].w;
				if(flag[e[i].to]==0){
					q.push(e[i].to);
					flag[e[i].to]=1;
				}
				
				cnt[e[i].to]=cnt[t]+1;
				if(cnt[e[i].to]>n+2){
					return 1;
				}
			}
		}
	}
	return 0;
}
void geth(){
	queue<int> q;
	memset(h,0x3f,sizeof(h));
	q.push(0);
	flag[0]=1;
	h[0]=0;
	while(q.empty()==0){
		long long t=q.front();
		q.pop();
		flag[t]=0;
		for(int i=head[t];i;i=e[i].next){
			int to=e[i].to;
			if(h[to]>h[t]+e[i].w){
				h[to]=h[t]+e[i].w;
				if(flag[to]==0){
					q.push(e[i].to);
					flag[to]=1;	
				}		
			}
		}
	}
}
void dijkstra(long long p){
	priority_queue<pii, vector<pii>, greater<pii>> qt;

	for(int j=1;j<=n;j++){
		dist[j]=1000000000;
	}
	memset(flag,0,sizeof(flag));
	qt.push({0,p});
	dist[p]=0;
	while(qt.empty()==0){
		pii tmp=qt.top();
		long long t=tmp.second;
		qt.pop();
		if(flag[t]==1){
			continue;
		}
		flag[t]=1;
		for(long long j=head[t];j!=0;j=e[j].next){
			if(flag[e[j].to]==0&&dist[e[j].to]>dist[t]+e[j].w){
				dist[e[j].to]=dist[t]+e[j].w;
				qt.push({dist[e[j].to],e[j].to});
			}
		}
	}
	
	
}
int main() {
	long long u,v,w;
	scanf("%d %d",&n,&m);
	for(int i=1;i<=n;i++){
		num++;
		e[num].to=i;
		e[num].w=0;
		e[num].next=head[0];
		head[0]=num;
	}
	long long s=num+1;	
	for(int i=1;i<=m;i++){
		scanf("%lld %lld %lld",&u,&v,&w);
		num++;
		e[num].to=v;
		e[num].w=w;
		e[num].next=head[u];
		head[u]=num;
	}
	if(spfa()){
		printf("-1\n");
		return 0;
	}
	memset(flag,0,sizeof(flag));
	memset(h,63,sizeof(h));
	geth();
	int tag[60005];//标记边权是否更新 
	for(int i=1;i<=n;i++){
		for(int j=head[i];j!=0;j=e[j].next){
				e[j].w=e[j].w+(h[i]-h[e[j].to]);
		}	
	}
	for(long long i=1;i<=n;i++){
		dijkstra(i);	
		long long ans=0;
		for(long long j=1;j<=n;j++){
			if(dist[j]==1000000000){
				ans+=(long long)(j*1000000000);
			}
			else{
				ans+=(long long)(j*(dist[j]+h[j]-h[i]));
			}
		}
		printf("%lld\n",ans);
	}
	
	return 0;
}