图论最短路算法模板

最短路算法

floyd

时间复杂度： O(V³)

适用范围： 适用数据量小的题目，程序简单，可求出所有结点间的最短路径，适用带负边权的图，如果存在G[i][i]为负数，则存在负环。

基本思路： 逐个加入节点作为中转点，更新起点到所有点的最短路。

模板：

//第一行输入n, m, 后m行输入u, v, w, 求第一个结点到第n个结点距离。(无向图)
#include <bits/stdc++.h>
using namespace std;

#define inf 0x3f3f3f3f
#define maxn 210

int G[maxn][maxn];//存储任意两点距离

void floyd(int s, int e, int n){
	for(int k = 1; k <= n; ++k){
		for(int i = 1; i <= n; ++i){
			for(int j = 1; j <= n; ++j){
				//以第k个结点作为中转点
				if(G[i][j] > G[i][k] + G[k][j]){
					G[i][j] = G[i][k] + G[k][j];
				}
			}
		}
	}
	printf("%d\n", G[s][e]);
}
int main(){
	scanf("%d%d", &n, &m);
	for(int i = 1; i <= n; ++i){
		for(int j = 1; j <= n; ++j){
			G[i][j] = inf;
		}
	}
	while(m--){
		int u, v, w;
		scanf("%d%d%d", &u, &v, &w);
		G[u][v] = G[v][u] = w;
	}
	floyd(1, n);
	return 0;
}

bellman-ford

时间复杂度： O(V*E)

适用范围： 适用求单源最短路径，方便打印路径，适用于存在负边权的图，可额外循环一次，若仍可以更新，则说明存在负环。

基本思路： 邻居问路模型，每次最少可求出1个点到起点的最短路，循环n-1次，求得所有点到起点的最短路。

模板：

//第一行输入n, m, 后m行输入u, v, w, 求第一个结点到第n个结点距离。(有向图)
#include <bits/stdc++.h>
using namespace std;

#define inf 0x3f3f3f3f
#define maxn 1010
#define maxm 10010

int d[maxn];
int u[maxm], v[maxm], w[maxm];

void bellman(int s, int e, int n, int m){
	for(int i = 1; i <= n; ++i){
		d[i] = inf;
	}
	d[s] = 0;
	for(int k = 1; k < n; ++k){
		for(int i = 1; i <= m; ++i){
			if(d[u[i]] + w[i] < d[v[i]]){
				d[v[i]] = d[u[i]] + w[i];
				//此处可存储路径
				//pre[v[i]] = u[i];
			}
		}
	}
	printf("%d\n", d[e]);
}

int main(){
	scanf("%d%d", &n, &m);
	for(int i = 1; i <= m; ++i){
		scanf("%d%d%d", &u[i], v[i], w[i]);
	}
	bellman(1, 1, n, m);
	return 0;
}

dijkstra

时间复杂度： O(Elog2V)

适用范围： 适用无负边权的图单源最短路问题，可求路径。

基本思路： 从起点出发，找到邻接的距离最近点，即确定了该点的最短路径，然后将该点连接的点加入队列，再从中选出一个距起点最近点，即确定了其最短路，依次类推，即每次迭代可至少确定一个点的最短路径。

模板：

//第一行输入n, m, 后m行输入u, v, w, 求第一个结点到第n个结点距离。(无向图)
#include <bits/stdc++.h>
using namespace std;

#define inf 0x3f3f3f3f
#define maxn 1010

struct edge{
	int to;
	int dis;
	edge(int to, int dis) : to(to), dis(dis) {}
	bool operator < (const edge& b) const{
		return dis > b.dis;
	}
}
bool done[maxn];
int d[maxn];
vector<edge> G[maxn];

void dijkstra(int s, int e, int n){
	for(int i = 1; i <= n; ++i){
		d[i] = inf;
		done[i] = false;
	}
	d[s] = 0;
	priority_queue<edge> pq;
	pq.push(edge(s, 0));
	while(!pq.empty()){
		int u = pq.top().to;
		pq.pop();
		if(done[u]){
			continue;
		}
		done[u] = true;
		for(int i = 0; i < G[u].size(); ++i){
			edge e = G[u][i];
			if(done[e.to]){
				continue;
			}
			if(d[e.to] > d[u] + e.dis){
				d[e.to] = d[u] + e.dis;
				pq.push(edge(e.to, d[e.to]));
				//此处可记录路径
				//...
			}
		}
	}
	printf("%d\n", d[e]);
}

int main(){
	scanf("%d%d", &n, &m);
	while(m--){
		int u, v, w;
		scanf("%d%d%d", &u, &v, &w);
		G[u].pushback(edge(v, w));
		G[v].pushback(edge(u, w));
	}
	dijkstra(1, n, n);
	return 0;
}