15 最短路—SPFA算法

贝尔曼-福特算法（Bellman-Ford） 队列优化（SPFA）

Bellman-Ford算法在每实施一次松弛操作后，就会有一些顶点已经求得其最短路，此后这些顶点的最短路的估计值就会一直保持不变，不再受后续松弛操作的影响，但是每次还要判断是否需要松弛，浪费时间，我们将优化上面的程序，实现“每次仅对最短路估计值发生变化了的顶点的所有出边进行松弛操作”。

问题背景与定义

求下图中1号顶点到2、3、4、5号顶点的最短路径。

dis来存放1号顶点到其余各个顶点的最短路径。初始时dis【1】为0，其余为无穷大。接下来将1号顶点入队。队列这里用一个数组que以及两个分别指向队列头和尾的变量head和tail来实现。

  问题求解过程

 弹出队列的顶点1，并使用顶点1的连边对相连顶点进行松弛操作，松弛成功的顶点入队

弹出队列的顶点2，并使用顶点2的连边对相连顶点进行松弛操作，松弛成功的顶点（该顶点在队列中不能存在）入队

在对2号顶点处理完毕后，需要将2号顶点出队，并依次对剩下的顶点做相同的处理，直到队列为空为止。最终数组 dis和队列 que状态如下：

 算法流程：

（1） 初始化操作：可以使用邻接表或者邻接矩阵对点边进行数据存储，构建距离估计值数组dis，队列存在顶点标记数组book，构建队列，初始化队列标识与元素。

（2） 当队列不为空时循环进行松弛操作。

（3） 获取队列首顶点，使用连边对顶点进行松弛操作，松弛成功将对应，将对应顶点（判定队列中不存在）进行入队，所有连边处理完成后，首顶点出队，标记数组位清空。

（4） 打印1号顶点到所有顶点的最短距离。

  问题代码实现

#include <bits/stdc++.h>
using namespace std;

int u[101], v[101], w[101];
int First[101], Next[10001];
int _index = 0;
void add(int x, int y, int z) {
	_index++;
	u[_index] = x;
	v[_index] = y;
	w[_index] = z;
	Next[_index] = First[x];
	First[x] = _index;
}
int main() {
	int n = 5, m = 7;
//	cin >> n >> m;
	//读取边到邻接表
//	for (int i = 1; i <= m; i++) {
//		cin >> u[i] >> v[i] >> w[i];
//		Next[i] = First[u[i]];
//		First[u[i]] = i;
//	}
	add(1,2,2);
	add(1,5,10);
	add(2,3,3);
	add(2,5,7);
	add(3,4,4);
	add(4,5,5);
	add(5,3,6);

	//构建dis估计值数组和使用标识数组
	int dis[101];
	int book[101];
	for (int i = 1; i <= n; i++) {
		dis[i] = 9999;
		book[i] = 0;
	}
	dis[1] = 0;
	book[1] = 1;
	//构建队列
	int head = 1, tail = 1;
	int que[101];
	//将第一个点加入队列
	que[tail] = 1;
	tail++;

	//进入循环，开始进行松弛操作
	while (head != tail) {
		int p = que[head];
		int k = First[p];
		//寻找连边进行松弛，加入队列
		while (k != 0) {
			if (dis[v[k]] > dis[u[k]] + w[k]) { //松弛成功
				dis[v[k]] = dis[u[k]] + w[k];
				if (book[v[k]] == 0) {
					que[tail] = v[k];
					tail++;
					book[v[k]] = 1;
				}
			}
			k = Next[k]; //寻找下一条边
		}
		book[head] = 0; //撤销标识
		head++;      //弹出队列
	}
	//打印最短距离
	for (int i = 1; i <= n; i++) cout << dis[i] << " ";

	return 0;
}

最短路径算法的对比分析

Floyd算法虽然总体时间复杂度高，但是可以解决负权边，并且均摊到每一点对上，在所有的算法中还是属于较优的。另外，Floyd算法较小的编码复杂度也是它的一大优势。所以，如果要求的是所有点对间的最短路径，或者如果数据范围较小，则Floyd算法比较适合。Diikstra算法最大的弊端是它无法适应有负权边的图。但是Diikstra具有良好的可扩展性，扩展后可以适应很多问题。另外用堆优化的Dijkstra算法的时间复杂度可以达到O（Mlog(N)）。当边有负权时，需要使用 Bellman-Ford算法或者队列优化的 Bellman-Ford算法。因此我们选择最短路径算法时，要根据实际需求和每一种算法的特性，选择适合的算法。

图的邻接表数组表示

#include <bits/stdc++.h>
using namespace std;

const int N = 1010;
const int M = 10100;

int  v[M], w[M];
int _first[N], _next[M];
int i = 0;
void add(int _u, int _v, int _w) {  //加入一条边
	i++;
	v[i] = _v;
	_next[i] = _first[_u];
	_first[_u] = i;
	w[i] = _w;
}
void printU(int _u) {
	//访问从_u出发的所有边，遍历的代码如下，当_next[i]为0时遍历结束
	for (int i = _first[_u]; i; i = _next[i]) {
		int _v = v[i];
		int _w = w[i];
		cout << _u << "," << _v << "," << _w << endl;
	}
}
int main() {
	add(1,2,77);
	add(2,3,777);
	add(2,5,77777);
	add(3,5,77777);
	add(5,4,7777);
	add(5,1,7);
	
	for(int k=1;k<=5;k++){
		cout<<k<<endl;
		printU(k);
	}
	return 0;
}