算法系列——SPFA算法（贝尔曼-福特算法的队列优化形式）

本系列旨在用简单的人话讲解算法，尽可能避免晦涩的定义，读者可以短时间内理解算法原理及应用细节。我在努力！

本篇文章编程语言为Python，供参考。

 SPFA算法（贝尔曼-福特算法的队列优化形式）

用于负权图中计算一个节点到其他节点的最短路径。（Bellman-Ford算法的一种优化形式）

基本原理：建立一个队列，逐次用队首结点u对与之相连的全部结点v进行松弛操作，如果结点v的最短路径距离更新，且v不在队列中， 则加入队列，直到队列为空停止。

1. 算法实现

Bellman-Ford算法内容见另一篇博客：算法系列——贝尔曼福特算法（Bellman-Ford）。

附全部源码：

#北京 天津 郑州 济南 长沙 海南
# 0    1    2    3    4    5

#模拟从文件中读入图的各个路径
a = """
0 1 500
1 2 900
2 0 100
1 3 300
2 3 400
2 4 500
3 4 1300
3 5 1400
4 5 1500
"""

INF = float('inf')
N = 6

weight = []

def init():

    global weight
    
    #定义邻接矩阵 记录各城市之间的距离
    weight = [[INF if j!=i else 0 for j in range(N)] for i in range(N)]

    #解析数据
    b = [[int(i) for i in i.split(' ')] for i in a.split('\n') if i != '']

    for i in b:
        weight[i[0]][i[1]] = i[2]
        weight[i[1]][i[0]] = i[2]

init()

def SPFA(src, target):

    dist = [0 if i == src else INF for i in range(N)]

    last_update = [src if i != INF else -1 for i in dist]

    queue = []
    
    queue.append(src)    

    cnt = [0] * N

    while queue:
        now = queue.pop(0)
        for i in range(N):
            if weight[now][i] != INF and now != i and dist[i] > dist[now] + weight[now][i]:
                dist[i] = dist[now] + weight[now][i]
                last_update[i] = now
                if i not in queue:
                    queue.append(i)
                    cnt[i] += 1
                if cnt[i] >= N:
                    raise ValueError("存在负权回路")
                    
    #输出从起点到终点的路径结点
    tmp = target
    path = []
    while tmp != src:
        path.append(tmp)
        tmp = last_update[tmp]
    path.append(src)
    print("->".join([str(i) for i in reversed(path)]))
    
    return dist[target]

后记：至此，最短路径的几个常见的经典算法就都已经完工了，虽然脑子里忘得差不多了，但是好在记录下来了，随时可查，方便得多。

简单总结一下：

Dijkstra：可以求单源最短路径（不能存在负权，非负权图首选）

Floyd：可以求多源最短路径

Bellman-Ford：可以求单源最短路径（可以存在负权，可以检测负权回路，但效率不高，要加优化）

SPFA：Bellman-Ford的队列优化。