最短路径算法----Bellman-ford和SPFA算法

思路类似Dijkstra，可以处理负权边，还可以发现负权回路。

核心也是：对于边e(i,j), 如果w(i) + e(i,j) < w(j)，就更新w(j)。这是一个松弛操作，即：估计的最短路径值渐渐地被更加准确的值替代，直至得到最优解（wiki）

对于图

有

def bellman_ford(graph, start_node):
	# graph:n*n matrix
	# find min distance from start_node
	length = len(graph)
	s = {start_node:0}          # the minimum distance between node i and v

	# init s: O(Vertex)
	for node in xrange(0, length):
		if node == start_node:
			continue
		s[node] = max_int

	# loose
	# run (vertex - 1) times
	for v in xrange(1, length):
		# for every edge
		for i in xrange(0, length):
			for j in xrange(0, length):
				if graph[i][j] != max_int and s[i] + graph[i][j] < s[j]:
					s[j] = s[i] + graph[i][j]

	return s

使用二维矩阵表示图，时间复杂度是O(Vertex^3)；

如果使用图数据结构，可以达到O(Vertex * Edge)

由于存在负权回路，还有一步检查的操作：

def test_negate_circle(graph, s):
	# for every edge
	length = len(graph)
	for i in xrange(0, length):
		for j in xrange(0, length):
			if graph[i][j] != max_int and s[i] + graph[i][j] < s[j]:
				return True
	return False

如果有负值回路，就说明永远能找到到目标点更小的一条边。

为什么需要遍历Vertex-1遍呢？我认为和遍历图的所有节点的深度有关：

对于上面的第一张图，深度为1，显然只需要遍历一次边就能得到结果了。但是对于第二张图，在最坏的情况下，需要遍历3次才可以。

下面假设所有边的权值为1，人肉模拟一下最坏结果：

第一遍：u:{0:0, 1:1, 2:max_int, 3:max_int}

第二遍：u:{0:0, 1:1, 2:2, 3:max_int}

第三遍：u:{0:0, 1:1, 2:2, 3:3}

所以，遍历Vertex-1次可以改为：遍历所有边的最大深度。

什么是遍历所有边的最大深度？

从上图来看，如果用BFS遍历所有点得到图的深度为2：

第零层：0

第一层：1,2

第二层：3

但是实际上，可能存在0->1->2->3，使得0~3的距离最短。

遍历所有边的最大深度的结果则是：

第零层：0

第一层：1[e(0,1)]，2[e(0,2)]

第二层：2[e(1,2)]

第三层：3[e(2,3)]

这个层数只是估算出来的最坏情况，也就是循环次数的上界

实际上，如果在一次遍历所有的边的时候，没有松弛操作，那么继续遍历也没有意义了。

这就是SPFA的思想：松弛操作必定只会发生在最短路径前导节点松弛成功过的节点上，用一个队列记录松弛过的节点，可以避免了冗余计算。

也就是说，只有对更新过的w(i)，才有可能出现w(i) + e(i,j) < w(j)。第一个更新的就是开始节点啦，更新后的权重为0。

def SPFA(graph, start_node):
	length = len(graph)
	s = {i:max_int for i in xrange(0, length)}
	s[start_node] = 0
	queue_loose = deque([start_node])
	circle_tester = defaultdict(lambda : 0)

	while queue_loose:
		i = queue_loose.popleft()
		# update s
		for j in xrange(0, length):
			if graph[i][j] != max_int and s[i] + graph[i][j] < s[j]:
				s[j] = s[i] + graph[i][j]
				queue_loose.append(j)

				# test circle
				circle_tester[j] += 1
				if circle_tester[j] == length:
					# has negate circle
					return None
	return s

负权环的检测我也写在SPFA里面了，如果一个节点访问次数大于Vertex次，就认为有环。

原因我猜想是：最多有Vextex-1个节点（除去自己）会对某个节点产生影响，如果大于这个数，说明有负环。

如果不对，希望大家提出指正~谢谢

驱动

graph = [[0, 7, 9,  max_int,  max_int, 14],
         [7, 0, 10, 15, max_int, max_int],
         [9, 10, 0, 11, max_int, 2],
         [max_int, 15, 11, 0, 6, max_int],
         [max_int, max_int,  max_int,  6, 0, 9],
         [14, max_int,  2,  max_int, 9, 0]]
print SPFA(graph, 0)