超级全面的最短路径算法（Bellman-Ford、SPFA、Dijkstra、Floyd）附习题若干

鉴于某些不可告人的原因特做此片。

最短路径算法

1、Bellman-Ford算法的实现及运用

一、知识讲解

Bellman-Ford算法是一种用于求单源最短路径的算法。在此要先讲明何为最短路，顾名思义即为两点间最短的距离。标准定义为：对在权图G=(V,E),（其中V为点集，E为边集）从一个源点s到汇点t有很多路径，其中路径上权和最少的路径，称从s到t的最短路径。如下图（图为无向图）：

该图中A,B间的最短路为A => C => B，即3 + 2 = 5；
A，E间的最短路为A => C => E，即3 + 4 = 7；
B，E间的最短路为B => C => E，即2 + 4 = 6。诸如此类。
那么知道定义后我们可以开始讲解Bellman-Ford算法的实现。

二、算法实现

Bellman-Ford算法核心思想为对n个点进行m次松弛操作（m为边数）。松弛操作为if (dis[tov[i]] > dis[u] + val[i]) dis[tov[i]] = dis[u] + val[i];（其中dis[i]表示从起点出发到第i号点的最短距离，tov[i]为第i条边所指向的点，u为当前节点即第i条边指的另一个节点，val[i]为第i条边的边权。）那么你每次松弛后都更新了dis[tov[i]]的最小值。当每个点做完m次松弛操作后最小值便已确定。那么时间复杂度为O(VE)。是一种时间复杂度并不是很优秀的单源最短路径算法，不过可以像后文提及的SPFA算法一样处理负边权的情况。

例1 单源最短路径【模板】（path，1s，125MB）

【问题描述】
给出一张有向图，请输出从某一点出发到所有点的最短路径。
【输入格式】
第一行包含三个整数N、M、S，分别表示点的个数、有向边的个数、出发点的编号。接下来M行每行包含三个整数Fi、Gi、Wi，分别表示第i条有向边的出发点、目标点和长度。
【输出格式】
一行，包含N个用空格分隔的整数，其中第i个整数表示从点S出发到点i的最短路径长度（若S=i则最短路径长度为0，若从点S无法到达点i，则最短路径长度为-1）
【输入样例】
4 6 1
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4
【输出样例】
0 2 4 3
【数据范围】
n <= 1000,m <= 50000
【问题分析】
这是一道单源最短路径的模板题，与上文思路一致，不再赘述。代码如下：

// program 4.3.1
#include <cstdio>
#include <cstring>
#define maxn 1010
#define maxm 50010
using namespace std;

const int N = 1e3 + 10;
const int M = 5e3 + 10;
const int inf = 0x3f3f3f3f;
int n,m,s,cnt,tov[maxm],from[maxm],dis[maxn],val[maxm];

void add(int u,int v,int w)
{
   
	tov[++ cnt] = v;
	from[cnt] = u;
	val[cnt] = w;
}

int main()
{
   
	memset(dis,0x3f,sizeof dis); //初始化，将距离赋为极大值以便后面松弛操作。
	scanf("%d%d%d",&n,&m,&s);
	for (int i = 1,u,v,w; i <= m; i ++) scanf("%d%d%d",&u,&v,&w),add(u,v,w); //加边操作。
	dis[s] = 0;
	for (int i = 1; i <= n; i ++)
		for (int j = 1; j <= m; j ++)
			if (dis[tov[j]] > dis[from[j]] + val[j]) dis[tov[j]] = dis[from[j]] + val[j]; //松弛操作。
	for (int i = 1; i <= n; i ++) 
		if (dis[i] == inf) printf("-1 "); else printf("%d ",dis[i]);
	return 0;
}

---

2、SPFA算法的实现及运用

一、知识讲解

SPFA算法也是一种用于求单源最短路径的算法，不过相比起Bellman-Ford，此算法运用到了队列优化，松弛操作与前者相似。不过将时间复杂度降低到O(km)，m是边数，k是一个常数，在最坏情况下k会达到n（点数）。所以SPFA的的平均运行速度较快，但是在遇到稠密图的时候会比较慢，所以在联赛中常会被卡，但是这是一种较常用最短路径的算法。

（图片来自百度百科）
从s点出发(s与s的距离是0，未连接我们视为无限大)

a b c d e f g
0 ∞ ∞ ∞ ∞ ∞ ∞
枚举a出发的所有点。
更新b,c,d。b,c,d均未在队列中，b,c,d入队，a出队。

a b c d e f g
0 24 8 15 ∞ ∞ ∞
b点：更新24 + 6=30 < dis[e],判断30<+∞,因此更新e。
e点入队，b出队。

a b c d e f g
0 24 8 15 30 ∞ ∞
c点：8+7=15 < dis[e],因此更新e但并不入队，因为e已经在队列中，只需更新dis[e]即可。
9+3=12 < dis[f],因此更新f。
f入队，c出队。

a b c d e f g
0 24 8 15 15 12 ∞
一直这样下去更新完所有点。

二、算法实现

例2 单源最短路径【模板】（path，1s，125MB）

【问题描述】
给出一张有向图，请输出从某一点出发到所有点的最短路径。（保证数据随机）
【输入格式】
第一行包含三个整数N、M、S，分别表示点的个数、有向边的个数、出发点的编号。接下来M行每行包含三个整数Fi、Gi、Wi，分别表示第i条有向边的出发点、目标点和长度。
【输出格式】
一行，包含N个用空格分隔的整数，其中第i个整数表示从点S出发到点i的最短路径长度（若S=i则最短路径长度为0，若从点S无法到达点i，则最短路径长度为-1）
【输入样例】
4 6 1
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4
【输出样例】
0 2 4 3
【数据范围】
n <= 10000,m <= 500000

【问题分析】
这是一道单源最短路径的模板题，数据范围比之例1更大，与上文思路一致，不再赘述。代码如下：

// program 4.3.2
#include <cstring>
#include <cstdio>
using namespace std;

const int maxm = 5e5 + 10;
const int maxn = 1e5 + 10;
const int inf = 0x3f3f3f3f;
struct Edge{
   
	int to,next,val;
} f[maxm];
int n,m,s,stu[maxn],cnt,dis[maxn],que[maxn * 5];
bool vis[maxn];

void add(int u,int v,int w)
{
   
	cnt ++;
	f[cnt].to = v;
	f[cnt].val = w;
	f[cnt].next = stu[u];
	stu[u] = cnt;
} //链式前向星连边

void SPFA()
{
   
	int head = 0,tail = 1;
	memset(dis,0x3f,sizeof(dis));
	vis[s] = 1;
	dis[s] = 0;
	que[tail] = s;
	while (head < tail)
	{
   
		head ++;
		int u = que[head]; //取出队首。
		for (int i = stu[u]; i ; i = f[i].next)
			if (f[i].val + dis[u] < dis[f[i].to]) //松弛操作。
			{
   
				dis[f[i].to] = f[i].val + dis[u];
				if (!vis[f[i].to]) //若没在队列中则入队
					vis[f[i].to] = 1,que[++ tail] = f[i].to; //入队，并打上标记。
			}
		vis[u] = 0;
	}
}

int main()
{
   
	scanf("%d%d%d",&n,&m,&s);
	for (int i = 1,u,v,w; i <= m; i ++) scanf("%d%d%d",&u,&v,&w),add(u,v,w);
	SPFA();
	for (int i = 1; i <= n; i ++) 
		if (dis[i] == inf) printf("-1 "); else printf("%d ",dis[i]);
	return 0;
}

---

3、Dijkstra算法的实现及运用

一、知识讲解

Dijkastra算法还是是一种用于求单源最短路的方法，但不能处理有负边权的情况。朴素的Dijkstra的思路是刚开始将dis数组的初值都赋为无穷大然后将起点的dis赋为零，然后每次取出当前没跑过的点中，dis值最小的点，取出来做松弛操作，然后以此类推跑完所有点后，答案就出来了。正确性证明，由于你每次取出当前dis最小的点，又因为没有负边，所以当前点一定已经是最小值，再者每次用最小距离更新出来的点一定是当前最优的。那么时间复杂度是O(n * n)的，但这并不是本节重点，因此直接给出含注释的标程。

// program 4.3.3
#include <cstring>
#include <cstdio>
using namespace std;

const int maxm = 5e5 + 10;
const int maxn = 1e5 + 10;
const int inf = 0x3f3f3f3f;
struct Edge{
   
	int to,next,val;
} f[maxm];
int n,m,s,stu[maxn],cnt,dis[maxn],que[maxn * 5];
bool vis[maxn];

void add(int u,int v,int w)
{
   
	cnt ++;
	f[cnt].to = v;
	f[cnt].val = w