【学习笔记】 Johnson 全源最短路

前置扯淡

一年多前学的最短路，当时就会了几个名词的拼写，啥也没想过

几个月之前，听说了“全源最短路”这个东西，当时也没说学一下，现在补一下（感觉实在是没啥用）

介绍

由于\(spfa\)容易被卡，实际上我们在\(O(nlog \space n)\) 的算法只有堆优化的\(Dijkstra\)

由于先天问题，\(Dijkstra\)无法处理在负权图上的问题

所以“\(Johnson\)全源最短路”算法就应运而生了

算法流程

我们针对\(Dijkstra\)无法处理负权图进行优化

我们考虑如何把每条边的权值转化成正数

这里引入“势能”的概念

势能需要一个起始点：建立一个虚拟源点（类网络流？），向每一个点连一条权值为\(0\)的有向边

跑一遍\(spfa\)，记录每个点到虚拟源点的最短路，记为\(res[]\)

（这里问显然\(dis=0\)的同学，请注意这可能是一个负权图）

然后我们把每一条边的边权操作一下：

e[num].dis+=res[e[num].from]-res[e[num].to];

这里\(e[]\)是前向星式建图

这样我们保证了每条边的权值都是正数（思考易得）

然后我们跑\(n\)次\(Dijkstra\)，最后

ans[from][to]-=res[from]-res[to];

复杂度\(O(n^2 \space log \space n)\)（\(spfa\)预处理复杂度忽略）

CODE

link-LGOJ5905 【模板】Johnson全源最短路

#include<bits/stdc++.h>
using namespace std;
#define int long long
namespace yspm{
	inline int read()
	{
		int res=0,f=1; char k;
		while(!isdigit(k=getchar())) if(k=='-') f=-1;
		while(isdigit(k)) res=res*10+k-'0',k=getchar();
		return res*f;
	}
	const int N=4e3+10;
	struct node{int to,dis,nxt;}e[N<<3];
	int head[N],n,m,cnt,app[N],res[N],ans,tmp[N]; bool vis[N];
	inline void add(int u,int v,int w)
	{
		e[++cnt].dis=w; e[cnt].nxt=head[u]; e[cnt].to=v;
		return head[u]=cnt,void();
	}
	inline bool spfa(int s)
	{
		queue<int> q; memset(res,0x3f,sizeof(res));
		q.push(s); vis[s]=1; res[s]=0;
		while(!q.empty())
		{
			int fr=q.front(); q.pop(); vis[fr]=0;
			for(int i=head[fr];i;i=e[i].nxt)
			{
				int t=e[i].to,dist=e[i].dis+res[fr];
				if(res[t]>dist)
				{
					res[t]=dist;
					if(!vis[t])
					{
						if(++app[t]>=n) return 0;
						vis[t]=1; q.push(t);
					}
				 }
			}
		}
		return 1;
	}
	#define mp make_pair
	inline void dij(int s)
	{
		priority_queue<pair<int,int> > q;
		q.push(mp(0,s)); memset(vis,0,sizeof(vis));
		for(int i=1;i<=n;++i) tmp[i]=1e9; tmp[s]=0; ans=0;
		while(!q.empty())
		{
			int fr=q.top().second; q.pop();
			if(vis[fr]) continue; vis[fr]=1;
			for(int i=head[fr];i;i=e[i].nxt)
			{
				int t=e[i].to,dist=e[i].dis+tmp[fr];
				if(tmp[t]>dist)
				{
					tmp[t]=dist;
					if(!vis[t]) q.push(mp(-dist,t));
				}
			}
		}
		for(int i=1;i<=n;++i)
		{
			if(tmp[i]==1e9) ans+=tmp[i]*i;
			else ans+=i*(tmp[i]+res[i]-res[s]);
		}
		return printf("%lld\n",ans),void();
	}
	signed main()
	{
		n=read(); m=read(); for(int i=1,u,v,w;i<=m;++i) u=read(),v=read(),w=read(),add(u,v,w);
		for(int i=1;i<=n;++i) add(n+1,i,0); if(!spfa(n+1)) return puts("-1"),0;
		for(int i=1;i<=n;++i) for(int j=head[i];j;j=e[j].nxt) e[j].dis+=res[i]-res[e[j].to];
		for(int i=1;i<=n;++i) dij(i);
		return 0;
	}
}
signed main(){return yspm::main();}

应用前景

这个破玩意学它有什么用呢？

求解最小费用最大流就是不断求解最短路,然后通过最短路增广的过程

由于走反向边费用要取负,无法使用 \(Dijkstra\) 增广,只能通过 \(Bellman\text{-}Ford\)

而有了 \(Johnson\) 算法以后,就可以先做一轮 \(Bellman\text{-}Ford\),

然后不断通过 \(Dijkstra\) 增广，运行更稳定,效率更高

(死了但是老是诈尸的 \(SPFA\) 能少用一点是一点，虽然我没有在网络流实战中使用过这个算法)