spfa最短路算法

spfa最短路算法

概述

1. SPFA算法的全称是：Shortest Path Faster Algorithm
2. 为了避免最坏情况的出现，在正权图上应使用效率更高的Dijkstra算法。若给定的图存在负权边，类似Dijkstra算法等算法便没有了用武之地，SPFA算法便派上用场了。
3. 定理：只要最短路径存在，上述SPFA算法必定能求出最小值。证明：每次将点放入队尾，都是经过松弛操作达到的。换言之，每次的优化将会有某个点v的最短路径估计值d[v]变小。所以算法的执行会使d越来越小。由于我们假定图中不存在负权回路，所以每个结点都有最短路径值。因此，算法不会无限执行下去，随着d值的逐渐变小，直到到达最短路径值时，算法结束，这时的最短路径估计值就是对应结点的最短路径值。

算法原理与应用

原理解析

简洁起见，我们约定加权有向图G不存在负权回路，即最短路径一定存在。用数组d记录每个结点的最短路径估计值，而且用邻接表来存储图G。我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。

应用

1. 求带负权边的最短路
2. 判断是有负环：如果一个点进入队列达到n次，则表明图中存在负环，没有最短路径。

例题

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 impossible。

数据保证不存在负权回路。

输入格式
第一行包含整数 n 和 m。

接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。

如果路径不存在，则输出 impossible。

数据范围
1≤n,m≤10^5,
图中涉及边长绝对值均不超过 10000。

输入样例：
3 3
1 2 5
2 3 -3
1 3 4
输出样例：
2

import collections
N = 100010
M = 10000010
h = [-1] * N
e = [-1] * N
w = [M] * N
ne = [-1] * N
idx = 0
dist = [M] * N
st = [False] * N

def add(a, b, c) :
	global idx
	e[idx] = b
	w[idx] = c
	ne[idx] = h[a]
	h[a] = idx
	idx += 1
	
def spfa() :
	que = collections.deque()
	dist[1] = 0
	que.appendleft(1)
	st[1] = True
	while len(que) != 0 :
		t = que.pop()
		st[t] = False
		i = h[t] 
		while i != -1 :
			j = e[i]
			if dist[j] > dist[t] + w[i] :
				dist[j] = dist[t] + w[i]
				if not st[j] :
					st[j] = True
					que.appendleft(j)
			i = ne[i]
	if dist[n] >= M :
		return False
	else :
		return True
	
n, m = map(int, input())

for i in range(m) :
	x, y, z = map(int, input())
	add(x, y, z)

if not spfa() :
	print("impossible")
else :
	print(dist[n])

这里st数组的意义在于记录节点是否已经进入队列，防止重复加入队列，计算重复。
在某种意义上讲是一个BFS

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你判断图中是否存在负权回路。

输入格式
第一行包含整数 n 和 m。

接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式
如果图中存在负权回路，则输出 Yes，否则输出 No。

数据范围
1≤n≤2000,
1≤m≤10000,
图中涉及边长绝对值均不超过 10000。

输入样例：
3 3
1 2 -1
2 3 4
3 1 -4
输出样例：
Yes
难度：简单
时/空限制：1s / 64MB

import collections
N = 2010
M = 10010
h = [-1] * N
e = [-1] * N
w = [-1] * N
ne = [-1] * N
idx = 1
dist = [M] * N
cnt = [0] * N
st = [False] * N

def add(a, b, c) :
	global idx
	e[idx] = b
	w[idx] = c
	ne[idx] = h[a]
	h[a] = idx
	idx += 1

def spfa() :
	que = collections.deque()
	for i in range(1, n + 1) :
		que.appendleft(i)
		st[i] = True
	while len(que) != 0 :
		t = que.pop()
		st[t] = False
		i = h[t]
		while i != -1 :
			j = e[i]
			if dist[j] > dist[t] + w[i] :
				dist[j] = dist[t] + w[i]
				cnt[j] = cnt[t] + 1
				if cnt[j] >= n :#只要最短路能更新超过n次，则说明有负环
					return True
				if not st[j] :
					st[j] = True
					que.appendleft(j)
			i = ne[i]
	return False

n, m = map(int, input().split())

for i in range(m) :
	a, b, c = map(int, input().split())
	add(a, b, c)

if spfa() :
	print("Yes")
else :
	print("No") 

小结
判断是否有负环与求最短路的spfa的区别是，刚开始对dist初始化和入队的节点。
刚开始需要让所有节点入队，对每个节点更新到某个起始结点的距离，dist表示到那个距离无所谓，只需要记录其更新了n次即可说明存在负环。

总结

spfa是对Bellma-Ford算法的优化，通过一个队列，每次更新队列中节点的距离，通过一个st数组记录队列中的元素是否存在，避免重复添加。在判断负环时，通过一个cnt数组来记录每个节点松弛操作次数。