最短路径问题：SPFA（Shortest Path Faster Algorithm）算法

最新推荐文章于 2019-07-30 19:47:00 发布

睡得香的杭波

最新推荐文章于 2019-07-30 19:47:00 发布

阅读量1.1k

点赞数

分类专栏：算法

算法专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1、理论准备

为了学习网络流，先水一道spfa。

SPFA算法是1994年西南交通大学段凡丁提出，只要最短路径存在，SPFA算法必定能求出最小值，SPFA对Bellman-Ford算法优化的关键之处在于意识到：只有那些在前一遍松弛中改变了距离估计值的点，才可能引起他们的邻接点的距离估计值的改变。为什么队列为空就不改变了呢？就是因为要到下一点必须经过它的前一个邻接点。。SPFA可以处理负权边。很多时候，给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。简洁起见，我们约定有向加权图G不存在负权回路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路。

初始化： dis数组全部赋值为Inf(无穷大，不能是map[s][i]),path数组全部赋值为s（即源点），或者赋值为-1，表示还没有知道前驱,然后dis[s]=0; 表示源点不用求最短路径，或者说最短路就是0。将源点入队；另外记住在整个算法中有顶点入队了要记得标记vis数组，有顶点出队了记得消除那个标记(可能多次入队)。

核心：读取队头顶点u，并将队头顶点u出队（记得消除标记）；将与点u相连的所有点v进行松弛操作，如果能更新估计值（即令d[v]变小），那么就更新，另外，如果点v没有在队列中，那么要将点v入队（记得标记），如果已经在队列中了，那么就不用入队以此循环，直到队空为止就完成了单源最短路的求解。

判断有无负环：如果某个点进入队列的次数超过N次则存在负环(SPFA无法处理带负环的图)，假设这个节点的入度是k(无向权则就是这个节点的连接的边)如果进入这个队列超过k,说明必然有某个边重复了，即成环；换一种思路：用DFS，假设存在负环a1->a2->…->an->a1。那么当从a1深搜下去时又遇到了a1，那么直接可以判断负环了所有用。当某个节点n次进入队列，则存在负环，此时时间复杂度为O(n*m),n为节点，m为边。

SPFA算法有两个优化算法 SLF 和 LLL： SLF：Small Label First 策略，设要加入的节点是j，队首元素为i，若dist(j)<dist(i)，则将j插入队首，否则插入队尾。 LLL：Large Label Last 策略，设队首元素为i，队列中所有dist值的平均值为x，若dist(i)>x则将i插入到队尾，查找下一元素，直到找到某一i使得dist(i)<=x，则将i出对进行松弛操作。 SLF 可使速度提高 15 ~ 20%；SLF + LLL 可提高约 50%。在实际的应用中SPFA的算法时间效率不是很稳定，为了避免最坏情况的出现，通常使用效率更加稳定的Dijkstra算法。个人觉得LLL优化每次要求平均值，不太好，为了简单，我们可以之间用c++STL里面的优先队列来进行SLF优化。

2、把HDU 1874 AC吧

Java代码如下：

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;

/*
 * HDU 1874
 * 原来一直wa，重写了一遍，AC了
 * SLF优化
 */

public class Main {
	static int n, m;
	static int[][]   map = new int[205][205];
	static int[]     dis = new int[205];
	static boolean[] vis = new boolean[205];
	/*
	 * 路径最大值是10000，不能设置成10005就行，还要考虑和
	 * 也不能是整形最大值，否则一加就溢出了
	 */
	static final int Inf = 0x3f3f3f3f;
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		// 记录前驱点 。若path[i]=j,表示从s到i的最短路径中i的前一个点是j
		// int[] path;
		int u, v, w;
		while (sc.hasNext()) {
			n = sc.nextInt();
			m = sc.nextInt();
			for (int i = 0; i < 205; i++) {
				for (int j = i; j < 205; j++) {
					map[i][j] = Inf;
					map[j][i] = Inf;
				}
			}
			for (int i = 0; i < m; i++) {
				u = sc.nextInt();//城市1
				v = sc.nextInt();//城市2
				w = sc.nextInt();//路长
				// 多重边
				if (map[u][v] > w) {
					map[v][u] = w;
					map[u][v] = w;
				}
			}
			int s = sc.nextInt();
			int t = sc.nextInt();
			SPFA(s);
			// 题目上有s t<n，所以不必判断dis[t]是否越界
			// 起点终点相同的话答案是0
			if ( dis[t] == Inf) {
				System.out.println(-1);
			} 
			else {
				System.out.println(dis[t]);
			}
		}
	}
	private static void SPFA(int s) {
		for (int i = 0; i < 205; i++) {
			vis[i] = false;
			// 初始化为map[s][i]第一组数据就错了
			dis[i] = Inf;
		}
		dis[s] = 0;
		vis[s] = true;
		Comparator<Integer> cmp = new Comparator<Integer>() {
			public int compare(Integer o1, Integer o2) {
				int i = (int) o1;
				int j = (int) 02;
				if (dis[i] > dis[j]) {
					return 1;
				} else if (dis[i] == dis[j]) {
					return 0;
				} else {
					return -1;
				}
			}
		};
		Queue<Integer> q = new PriorityQueue<Integer>(205, cmp);
		q.clear();
		q.add(s);
		while (!q.isEmpty()) {
			int head = q.poll();
			// 该注意的是有些点可能重复入队，所以出队的点也要重新置未标记
			vis[head] = false;
				for (int i = 0; i < n; i++) {
						// dis[head]不可能是INF，map[head][i]可能是INF
						if (dis[head] + map[head][i] < dis[i]) {
							// path[i] = head
							dis[i] = dis[head] + map[head][i];
							if (!vis[i]) {
								// 用一个数组在此记录入队次数，大于n就存在负环；如何事先判断
								q.add(i);
								vis[i] = true;
							}
						}
				}
		}
	}
}

转载博客链接：

http://www.cnblogs.com/hxsyl/p/3248391.html

==============================================================================================================================

C++版本SPFA算法代码和解释：

/*
 * 单源最短路算法SPFA,时间复杂度O(kE),k在一般情况下不大于2,对于每个顶点使用可以在O(VE)的时间内算出每对节点之间的最短路
 * 使用了队列,对于任意在队列中的点连着的点进行松弛,同时将不在队列中的连着的点入队,直到队空则算法结束,最短路求出
 * SPFA是Bellman-Ford的优化版,可以处理有负权边的情况
 * 对于负环,我们可以证明每个点入队次数不会超过V,所以我们可以记录每个点的入队次数,如果超过V则表示其出现负环,算法结束
 * 由于要对点的每一条边进行枚举,故采用邻接表时时间复杂度为O(kE),采用矩阵时时间复杂度为O(kV^2)
 */
#include<cstdio>
#include<vector>
#include<queue>
#define MAXV 10000
#define INF 1000000000 //此处建议不要过大或过小,过大易导致运算时溢出,过小可能会被判定为真正的距离
 
using std::vector;
using std::queue;
 
struct Edge{
	int v; //边权
	int to; //连接的点
};
 
vector<Edge> e[MAXV]; //由于一般情况下E<<V*V,故在此选用了vector动态数组存储,也可以使用链表存储
int dist[MAXV]; //存储到原点0的距离,可以开二维数组存储每对节点之间的距离
int cnt[MAXV]; //记录入队次数,超过V则退出
queue<int> buff; //队列,用于存储在SPFA算法中的需要松弛的节点
bool done[MAXV]; //用于判断该节点是否已经在队列中
int V; //节点数
int E; //边数
 
bool spfa(const int st){ //返回值:TRUE为找到最短路返回,FALSE表示出现负环退出
	for(int i=0;i<V;i++){ //初始化:将除了原点st的距离外的所有点到st的距离均赋上一个极大值
		if(i==st){
			dist[st]=0; //原点距离为0;
			continue;
		}
		dist[i]=INF; //非原点距离无穷大
	}
	buff.push(st); //原点入队
	done[st]=1; //标记原点已经入队
	cnt[st]=1; //修改入队次数为1
	while(!buff.empty()){ //队列非空,需要继续松弛
		int tmp=buff.front(); //取出队首元素
		for(int i=0;i<(int)e[tmp].size();i++){ //枚举该边连接的每一条边
			Edge *t=&e[tmp][i]; //由于vector的寻址速度较慢,故在此进行一次优化
			if(dist[tmp]+(*t).v<dist[(*t).to]){ //更改后距离更短,进行松弛操作
				dist[(*t).to]=dist[tmp]+(*t).v; //更改边权值
				if(!done[(*t).to]){ //没有入队,则将其入队
					buff.push((*t).to); //将节点压入队列
					done[(*t).to]=1; //标记节点已经入队
					cnt[(*t).to]+=1; //节点入队次数自增
					if(cnt[(*t).to]>V){ //已经超过V次,出现负环
						while(!buff.empty())buff.pop(); //清空队列,释放内存
						return false; //返回FALSE
					}
				}
			}
		}
		buff.pop();//弹出队首节点
		done[tmp]=0;//将队首节点标记为未入队
	}
	return true; //返回TRUE
} //算法结束
 
int main(){ //主函数
	scanf("%d%d",&V,&E); //读入点数和边数
	for(int i=0,x,y,l;i<E;i++){
		scanf("%d%d%d",&x,&y,&l); //读入x,y,l表示从x->y有一条有向边长度为l
		Edge tmp; //设置一个临时变量,以便存入vector
		tmp.v=l; //设置边权
		tmp.to=y; //设置连接节点
		e[x].push_back(tmp); //将这条边压入x的表中
	}
	if(!spfa(0)){ //出现负环
		printf("出现负环,最短路不存在\n");
	}else{ //存在最短路
		printf("节点0到节点%d的最短距离为%d",V-1,dist[V-1]);
	}
	return 0;
}

转载博客链接

http://www.nocow.cn/index.php/SPFA算法