10.4 单源负权Bellman–Ford算法

  这个算法是用来计算负权重图最短路径的算法，用途比较少。因为很少有负权重图。因为存在负权重，所以不能使用Dijkstra算法。但是Bellman–Ford也无法处理有负权重环的情况。
  算法步骤：
  首先初始化一个距离数组，距离全为正无穷，到起始点的距离为0。这个距离数组代表起始点到其他点的距离。然后双层循环所有的边。每个边，有开始点u到结束点v，设起始点为s，这个时候存在三个距离，如下图所示：

  如果$d[u]+w(u,v)<d[v]$，那么就将$d[u]+w(u,v)$作为新的$d[v]$。算法思想简单吧。

def bellman_ford(self, start_index):
    # 设置初始化距离全部为正无穷
    d = [float('inf') for _ in self.__vertices]
    predecessors = [ None for _ in self.__vertices]
    d[start_index] = 0
    for v in self.__vertices:
        for e in self.__edges:
            u = e.from_index
            v = e.to_index
            dv = d[v]
            d[v] = min(d[v], d[u]+e.weight())
            if dv != d[v]:
                predecessors[v] = u

    for e in self.__edges:
        u = e.from_index
        v = e.to_index
        if d[v] > d[u] + e.weight():
            raise RuntimeError('存在负权重环')
    return d, predecessors

以这个图为例子

测试代码

class MyTestCase(unittest.TestCase):
    def test_bfs(self):
        # 定义一个图，测试BFS搜索
        graph = self.create_graph()
        path = graph.bellman_ford(3)
        print(path)

    def create_graph(self):
        vertices = ['A', 'B', 'C', 'S']
        edges = [
            WeightedEdge(0,1,2),
            WeightedEdge(2,0,-2),
            WeightedEdge(2, 1, 1),
            WeightedEdge(3, 0, 1),
            WeightedEdge(3, 2, 2)
        ]
        graph = WeightedGraph()
        graph.vertices = vertices
        graph.edges = edges
        return graph

if __name__ == '__main__':
    unittest.main()

  因为是两层循环，所以算法复杂度是$O(mn)$，m是点的数量，n是每个点边的数量。