常见最短路模板

在 C++ 里有一些最短路的问题，题目需要你求出图中一点到另一点的最短距离，在这个时候，我们通常会使用最常见的 3 种方法。

一、Floyd

Floyd 一般用在数据较小的题目里，它的思想是用一个“转折点”去计算最优方案。

如：有 $A,B,C$ 三点，$AB$ 的距离是 $1$，$BC$ 的距离是 $2$，$AC$ 的距离是 $4$，那么求 $A$ 与 $C$ 的最短距离是多少？

Floyd 的思想就是把 $B$ 看作是一个“转折点”，就能求得 $A$ 与 $C$ 的最短距离是 $\min (4,1+2)=3$，即最短距离为 $3$。

所以，我们可以用到一个三重循环，去枚举“转折点”、起点以及终点，就能求出最短路了。

B3647【模板】Floyd

#include <bits/stdc++.h>
using namespace std;
int n,m;
int a,b,c;
int dp[5000][5000];
int main()
{
	cin >> n >> m;
	memset(dp,0x3f,sizeof(dp));
	for (int i = 1;i <= m;i++)
	{
		cin >> a >> b >> c;
		dp[a][b] = dp[b][a] = c;
		//dp[i][j]表示i->j的最短路
	}
	for (int k = 1;k <= n;k++)
	    for (int i = 1;i <= n;i++)
		    for (int j = 1;j <= n;j++)
				dp[i][j] = min(dp[i][j],dp[i][k]+dp[k][j]);
	for (int i = 1;i <= n;i++)
	{
		for (int j = 1;j <= n;j++)
		{
			//所有的点与点之间的最短路
			if (i != j) cout << dp[i][j] << ' ';
			else cout << "0 ";
		}
		cout << '\n';
	}
	return 0;
}

二、Dijkstra

Dijkstra 是一般题目标准数据都会用到的最短路算法。

它的思想与 bfs 差不多，不过利用了优先队列做优化，即把相邻两点之间距离最小的排在最前面。

P4779【模板】单源最短路径（标准版）

#include <bits/stdc++.h>
#define itn int
#define endl '\n'
#define N 500010
#define INF 1e9
#define pq priority_queue
using namespace std;
int n,m,s;
int head[N],to[N],nxt[N],w[N],E;
void add(int a,int b,int c)
{
	E++;
	to[E] = b;
	w[E] = c;
	nxt[E] = head[a];
	head[a] = E;
}
int d[N];
int vis[N];
struct node
{
	int u,dis;
	bool operator < (const node &cmp) const
	{
		return dis > cmp.dis;
	}
};
pq <node> q; //优先队列优化
void dijkstra()
{
	for (int i = 1;i <= n;i++) d[i] = INF;
	node tmp;
	tmp.u = s;
	tmp.dis = 0;
	q.push(tmp);
	d[s] = 0;
	while (!q.empty())
	{
		node f = q.top();
		q.pop();
		int u = f.u;
		if (vis[u]) continue;
		vis[u] = 1;
		for (int i = head[u];i;i = nxt[i])
		{
			int v = to[i];
			if (d[v] > d[u] + w[i])
			{
				d[v] = d[u] + w[i];
				node g;
				g.dis = d[v];
				g.u = v;
				q.push(g);
			}
		}
	}
}
signed main()
{
	cin >> n >> m >> s;
	for (int i = 1;i <= m;i++)
	{
		int x,y,z;
		cin >> x >> y >> z;
		add(x,y,z); 
	}
	dijkstra();
	for (int i = 1;i <= n;i++) cout << d[i] << ' ';
	return 0;
}

三、Bellman - Ford

Bellman - Ford 是专用于有负环的最短路中，思想与 Floyd 类似。

P3385【模板】负环

#include <bits/stdc++.h>
#define N 2000010
#define INF 0x7f7f7f7f
using namespace std;
int t; 
struct node
{
	int a,b,c;
}e[N];
int n,m,sum;
void add(int x,int y,int z)
{
	if (z < 0)
	{
		e[++sum].a = x;
		e[sum].b = y;
		e[sum].c = z;
	}
	else
	{
		e[++sum].a = x;
		e[sum].b = y;
		e[sum].c = z;
		e[++sum].a = y;
		e[sum].b = x;
		e[sum].c = z;
	}
}
int d[N];
bool bellman()
{
	memset(d,0,sizeof(d));
	for (int i = 2;i <= n;i++) d[i] = INF;
	for (int i = 1;i < n;i++)
		for (int j = 1;j <= sum;j++)
			if (d[e[j].a] != INF && d[e[j].a] + e[j].c < d[e[j].b])
				d[e[j].b] = d[e[j].a] + e[j].c;
	for (int i = 1;i <= sum;i++)
	{
		if (d[e[i].a] == INF || d[e[i].b] == INF) continue;
		if (d[e[i].a] + e[i].c < d[e[i].b]) return true; //存在负环 
	}
	return false;
}
int main()
{
	scanf("%d",&t);
	while (t--)
	{
		memset(e,0,sizeof(e));
		scanf("%d%d",&n,&m);
		for (int i = 1;i <= m;i++)
		{
			int x,y,z;
			scanf("%d%d%d",&x,&y,&z);
			add(x,y,z);
		}
		if (bellman()) printf("YES\n");
		else printf("NO\n");
	}
	return 0;
}