最短路模板

\(\texttt{Floyd}\)

全源最短路

使用环境：\(n\leq 500\)，可以有负边权

时间复杂度：\(\mathcal O(n^3)\)

void Floyd(){
	for(int k=1;k<=n;k++){
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
			}
		}
	}
	return;
}

\(\texttt{Dijkstra}\)

单源最短路

使用环境：\(n\leq 10^6,m\leq 3\times 10^6\)，不可以有负边权

时间复杂度：\(\mathcal O((n+m)\log m)\)

void Dijkstra(int s){
    priority_queue<node>q;
    q.push({0,s});
    dis[s]=0;
    while(q.size()){
        int u=q.top().u;
        q.pop();
        if(vis[u]){
            continue;
        }
        vis[u]=1;
        for(int i=0;i<G[u].size();i++){
            int v=G[u][i].v;
            int w=G[u][i].w;
            if(vis[v]){
                continue;
            }
            if(dis[v]>dis[u]+w){
                dis[v]=dis[u]+w;
                q.push({dis[v],v});
            }
        }
    }
    return;
}

\(\texttt{Bellman_Ford}\)

单源最短路

使用环境：\(n\leq 10^4,m\leq 10^4\)，可以有负边权

时间复杂度：\(\mathcal O(nm)\)

void Bellman_Ford(int s){
	dis[s]=0;
	for(int i=1;i<=n;i++){
		bool flag=0;
		for(int j=1;j<=n;j++){
			for(int k=0;k<G[j].size();k++){
				int v=G[j][k].v;
				int w=G[j][k].w;
				if(dis[v]>dis[j]+w){
					dis[v]=dis[j]+w;
					flag=1; 
				}
			}
		}
		if(flag==0){
			return;
		}
	}
	return;
}

\(\texttt{SPFA}\)

单源最短路

使用环境：\(n\leq 10^4,m\leq 10^4\)，可以有负边权

时间复杂度：\(\mathcal O(nm)\)

void SPFA(int s){
    queue<int>q;
    q.push(s);
    dis[s]=0;
    vis[s]=1;
    while(q.size()){
        int u=q.front();
        q.pop();
        vis[u]=0;
        for(int i=0;i<G[u].size();i++){
            int v=G[u][i].v;
            int w=G[u][i].w;
            if(dis[v]>dis[u]+w){
                dis[v]=dis[u]+w;
                if(vis[v]==0){
                    q.push(v);
                    vis[v]=1;
                }
            }
        }
    }
    return;
}

\(\texttt{Johnson}\)

全源最短路

使用环境：\(n\leq 5\times 10^3,m\leq 5\times 10^3\)，可以有负边权

时间复杂度：\(\mathcal O(n(n+m)\log m)\)

#include<bits/stdc++.h>
#define int long long
using namespace std;
int n,m;
int dist[3005];
int dis[3005];
bool vis[3005];
int in[3005];
struct edge{
	int v,w;
};
vector<edge>vec[3005];
void SPFA(int s){
	for(int i=0;i<=n;i++){
		dist[i]=1e9;
		vis[i]=0;
		in[i]=0;
	}
	queue<int>q;
	dist[s]=0;
	vis[s]=1;
	in[s]=1;
	q.push(s);
	while(q.size()){
		int u=q.front();
		q.pop();
		vis[u]=0;
		for(int i=0;i<vec[u].size();i++){
			int v=vec[u][i].v;
			int w=vec[u][i].w;
			if(dist[v]>dist[u]+w){
				dist[v]=dist[u]+w;
				if(vis[v]==0){
					vis[v]=1;
					in[v]++;
					q.push(v);
					if(in[v]>=n){
						cout<<-1;
						exit(0);
					}
				}
			}
		}
	}
	return;
}
struct node{
	int dis,u;
	bool operator<(const node&h)const{
		return dis>h.dis;
	}
};
void Dijkstra(int s){
	for(int i=1;i<=n;i++){
		dis[i]=1e9;
		vis[i]=0;
	}
	dis[s]=0;
	priority_queue<node>q;
	q.push({0,s});
	while(q.size()){
		int u=q.top().u;
		q.pop();
		if(vis[u]){
			continue;
		}
		vis[u]=1;
		for(int i=0;i<vec[u].size();i++){
			int v=vec[u][i].v;
			int w=vec[u][i].w;
			if(vis[v]){
				continue;
			}
			if(dis[v]>dis[u]+w){
				dis[v]=dis[u]+w;
				q.push({dis[v],v});
			}
		}
	}
	return;
}
signed main(){
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		int u,v,w;
		cin>>u>>v>>w;
		vec[u].push_back({v,w}); 
	} 
	for(int i=1;i<=n;i++){
		vec[0].push_back({i,0});
	}
	SPFA(0);
	for(int i=1;i<=n;i++){
		for(int j=0;j<vec[i].size();j++){
			int v=vec[i][j].v;
			vec[i][j].w+=dist[i]-dist[v];
		}
	}
	for(int i=1;i<=n;i++){
		Dijkstra(i);
		int cnt=0;
		for(int j=1;j<=n;j++){
			if(dis[j]==1e9){
				cnt+=j*1e9;
			}else{
				cnt+=j*(dis[j]+dist[j]-dist[i]);
			}
		}
		cout<<cnt<<"\n";
	}
	return 0;
}