算法训练营day60 图论⑩ Bellman_ford 队列优化算法、判断负权回路、单源有限最短路

增加对最短路径的优化算法、负权回路、单源有限最短的讲解

Bellman_ford 队列优化算法

我们之前的松弛算法，是对所有边进行松弛，真正有效的松弛，只有松弛边（节点1->节点2）和边（节点1->节点3）。而松弛边（节点4->节点6），边（节点5->节点3）等等都是无效的操作，因为节点4 和节点 5 都是没有被计算过的节点。所以 Bellman_ford 算法每次都是对所有边进行松弛，其实是多做了一些无用功。

只需要对上一次松弛的时候更新过的节点作为出发节点所连接的边进行松弛就够了。

基于以上思路，如何记录上次松弛的时候更新过的节点呢？用队列来记录。简单理解就是每次mindist数组中被更新过的位置就是需要入栈的元素，然后栈顶元素进行松弛操作出栈，同时被修改的元素入栈，最后完成所有的循环（其实用栈也行，对元素顺序没有要求）

效率分析

如果图越稠密，则 SPFA的效率越接近与 Bellman_ford。反之，图越稀疏，SPFA的效率就越高。一般来说，SPFA 的时间复杂度为 O(K * N) K 为不定值，因为节点需要计入几次队列取决于图的稠密度。

SPFA（队列优化版Bellman_ford）在理论上时间复杂度更胜一筹，但实际上，也要看图的稠密程度，如果图很大且非常稠密的情况下，虽然 SPFA的时间复杂度接近Bellman_ford，但实际时间消耗可能是 SPFA耗时更多。

代码实现

最根本的理解，我们这个代码是以边为主的，注意本题没有负权回路。

python 复制代码

import collections

def main():
    n, m = map(int, input().strip().split())
    edges = [[] for _ in range(n + 1)]
    for _ in range(m):
        src, dest, weight = map(int, input().strip().split())
        edges[src].append([dest, weight])
    
    minDist = [float("inf")] * (n + 1)
    minDist[1] = 0
    que = collections.deque([1])
    visited = [False] * (n + 1)
    visited[1] = True
    
    while que:
        cur = que.popleft()
        visited[cur] = False
        for dest, weight in edges[cur]:
            if minDist[cur] != float("inf") and minDist[cur] + weight < minDist[dest]:
                minDist[dest] = minDist[cur] + weight
                if visited[dest] == False:
                    que.append(dest)
                    visited[dest] = True
    
    if minDist[-1] == float("inf"):
        return "unconnected"
    return minDist[-1]

if __name__ == "__main__":
    print(main())

Bellman_ford 判断负权回路

本题是要我们判断负权回路，也就是图中出现环且环上的边总权值为负数。如果在这样的图中求最短路的话，就会在这个环里无限循环（也是负数+负数只会越来越小），无法求出最短路径。

在上期博客中，bellman_ford 算法的核心就是一句话：**对所有边进行 n-1 次松弛。在没有负权回路的图中，松弛 n 次以上，结果不会有变化。**但本题有负权回路，如果松弛 n 次，结果就会有变化了，因为有负权回路就是可以无限最短路径（一直绕圈，就可以一直得到无限小的最短距离）。

那么解决本题的核心思路，就是在 n-1 次松弛的基础上，再多松弛一次，看minDist数组是否发生变化。

Bellman-Ford方法

python 复制代码

import sys

def main():
    input = sys.stdin.read
    data = input().split()
    index = 0
    
    n = int(data[index])
    index += 1
    m = int(data[index])
    index += 1
    
    grid = []
    for i in range(m):
        p1 = int(data[index])
        index += 1
        p2 = int(data[index])
        index += 1
        val = int(data[index])
        index += 1
        # p1 指向 p2，权值为 val
        grid.append([p1, p2, val])

    start = 1  # 起点
    end = n    # 终点

    minDist = [float('inf')] * (n + 1)
    minDist[start] = 0
    flag = False

    for i in range(1, n + 1):  # 这里我们松弛n次，最后一次判断负权回路
        for side in grid:
            from_node = side[0]
            to = side[1]
            price = side[2]
            if i < n:
                if minDist[from_node] != float('inf') and minDist[to] > minDist[from_node] + price:
                    minDist[to] = minDist[from_node] + price
            else:  # 多加一次松弛判断负权回路
                if minDist[from_node] != float('inf') and minDist[to] > minDist[from_node] + price:
                    flag = True

    if flag:
        print("circle")
    elif minDist[end] == float('inf'):
        print("unconnected")
    else:
        print(minDist[end])

if __name__ == "__main__":
    main()

SPFA方法

这里涉及的问题是节点重复入队，导致本应n-1次结束的过程，没有按时结束，我们需要记录哪些节点已经出队列了，哪些节点在队列里面，对于已经出队列的节点不用统计入度

python 复制代码

from collections import deque
from math import inf

def main():
    n, m = [int(i) for i in input().split()]
    graph = [[] for _ in range(n+1)]
    min_dist = [inf for _ in range(n+1)]
    count = [0 for _ in range(n+1)]  # 记录节点加入队列的次数
    for _ in range(m):
        s, t, v = [int(i) for i in input().split()]
        graph[s].append([t, v])
        
    min_dist[1] = 0  # 初始化
    count[1] = 1
    d = deque([1])
    flag = False
    
    while d:  # 主循环
        cur_node = d.popleft()
        for next_node, val in graph[cur_node]:
            if min_dist[next_node] > min_dist[cur_node] + val:
                min_dist[next_node] = min_dist[cur_node] + val
                count[next_node] += 1
                if next_node not in d: # 二刷的时候再好好理解
                    d.append(next_node)
                if count[next_node] == n:  # 如果某个点松弛了n次，说明有负回路
                    flag = True
        if flag:
            break
            
    if flag:
        print("circle")
    else:
        if min_dist[-1] == inf:
            print("unconnected")
        else:
            print(min_dist[-1])


if __name__ == "__main__":
    main()

Bellman_ford 单源有限最短路

注意题目中描述是 最多经过 k 个城市的条件下，而不是一定经过k个城市，也可以经过的城市数量比k小，但要最短的路径。对于部分路径节点多但是距离短的结果增加了要求

在这个系列的第一个题目中我们讲了：对所有边松弛一次，相当于计算起点到达与起点一条边相连的节点的最短距离。节点数量为n，起点到终点，最多是 n-1 条边相连。那么对所有边松弛 n-1 次就一定能得到起点到达终点的最短距离。本题是最多经过 k 个城市，那么是 k + 1条边相连的节点。

下期这个题目出一个专题

python 复制代码

def main():
    # 輸入
    n, m = map(int, input().split())
    edges = list()
    for _ in range(m):
        edges.append(list(map(int, input().split() )))
    
    start, end, k = map(int, input().split())
    min_dist = [float('inf') for _ in range(n + 1)]
    min_dist[start] = 0
    
    # 只能經過k個城市，所以從起始點到中間有(k + 1)個邊連接
    # 需要鬆弛(k + 1)次
    
    for _ in range(k + 1):
        update = False
        min_dist_copy = min_dist.copy()
        for src, desc, w in edges:
            if (min_dist_copy[src] != float('inf') and 
            min_dist_copy[src] + w < min_dist[desc]):
                min_dist[desc] = min_dist_copy[src] + w
                update = True
        if not update:
            break
    # 輸出
    if min_dist[end] == float('inf'):
        print('unreachable')
    else:
        print(min_dist[end])
            
            

if __name__ == "__main__":
    main()