Bellman_Ford最短路径算法

根据算法导论上的说明:该算法可以说很简单,对每个节点维护两个信息,一个是源节点到该节点的距离,另一个是到该节点的前一个节点。也即前驱。假设当前用距离表A来保存所有点的这两个信息。假设有n个节点 算法分为三步步走。

第一步初始化A,A中所有距离均为无穷大,且前驱为空 第二步,计算距离。对图中的每条边(u,v,w)都进行relax操作。其意义是,测试是否可以对从源节点s到v的最短路径进行改善。方法是:利用A中维护从源节点到任意节点v的距离,若从节点u到v的距离比A中的小,则更新A中的距离为这个更小的值,且A中v节点的前驱也更新为u。这里在更新A中的节点V时,边(u,V)应该是节点v的一条弧(无向图中为以v为一端短点的边,有向图中则为以v为尾 的弧)。 第三步,检查是否存在权值为负的边,若存在,则不存在解决方案。 最后根据A中的信息构建路径。

最后自己硬着头皮写了一上午,调各种错误,之后调出正确结果之后才算有了一些自己的理解。 这个算法可以说
采用的思想是遍历比较。
对图中的每一个节点进行如下操作:

遍历与该节点u相邻的每一条边(u,v),若从源点经由u到v比从源点到v的距离短,则用这个短的距离来更新距离值,并且设置节点v的前驱为节点u。 当对所有的节点都进行了如上述所说的操作之后,最后得到的距离表和前驱表即可构建路径和距离信息。

下面是我用python写的一个代码示例,写的很粗糙。

import numpy as np
dist=np.array([[0,1,1,0.5,0,0],[1,0,0,1,1,0],[1,0,0,1,1,1],[0.5,1,1,0,1,0],[0,1,1,1,0,1],[0,0,1,0,1,0]])
def bf(adjacent_array,source):
    weight = adjacent_array
    node_num = len(adjacent_array[0])
    path = list(range(node_num))
    distance = [float("inf") for i in range(node_num)]
    distance[source-1] = 0

    i = 0
    while i < node_num:
        j = i
        while j < node_num:
            if weight[i][j]:
                if distance[i]+weight[i][j]<distance[j]:
                    distance[j] = distance[i]+weight[i][j]
                    path[j] = i
            j += 1
        i += 1
    i = 0
    while i < node_num:
        path_to = [i+1]
        j = i
        while j != source-1:
            path_to.insert(0,path[j]+1)
            j = path[j]
        print("the path to %d is:"%(i+1))
        print(path_to)
        i += 1
    print(distance)
bf(dist,1)
<< 运行结果如下
the path to 1 is:
[1]
the path to 2 is:
[1, 2]
the path to 3 is:
[1, 3]
the path to 4 is:
[1, 4]
the path to 5 is:
[1, 4, 5]
the path to 6 is:
[1, 3, 6]
[0, 1.0, 1.0, 0.5, 1.5, 2.0]
    原文作者:Bellman - ford算法
    原文地址: https://blog.csdn.net/Muyan_Donny/article/details/80987319
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞