数据结构（bellman-ford算法求最短路径）

最新推荐文章于 2025-08-14 15:32:21 发布

Jay Jonson

最新推荐文章于 2025-08-14 15:32:21 发布

阅读量979

点赞数

CC 4.0 BY-SA版权

分类专栏：数据结构文章标签： bellman-ford 数据结构算法

本文链接：https://blog.youkuaiyun.com/weixin_35641414/article/details/92294537

数据结构专栏收录该内容

1 篇文章

订阅专栏

本文深入探讨了Bellman-Ford算法，一种用于求解有向图中源点到所有其他点最短路径的经典算法。文章详细介绍了算法的流程、Python代码实现过程，并讨论了如何检测负权回路。适合对图算法感兴趣的读者。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

bellman-ford算法求源点到任意点最短路径

一、算法流程

初始化所有的node节点。每个节点中存储从源点到达这个节点的距离，源点的值为0，其它的节点则为无穷大。
循环节点，遍历所有的有向边，对有向边进行松弛计算，不断逼近正确的路线。
遍历所有的有向边 edges(start,end)可能出现的路线情况，如果出现
dicts[edge[‘end’]]> dicts[edge[‘start’]] + edge[‘weight’] 的情况，表示存在负权回路的情况，如果存在负权回路的话，就会因为出现无法收敛而导致不能求出最短路径的情况。

二、代码实现过程（python）

定义算法类

class Bellman_ford():
    def __init__(self,node_num:int,startedvertex:str):
        self.edges = []
        self.maxint = float('Inf')  #源点和某点不可达时的距离，无穷大
        self.dicts ={} #各边距离字典
        self.node_num = node_num #节点数
        self.startedvertex = startedvertex #源点字符

定义添加数据函数

    #判断字典是否存在node的下标，否则添加字典,初始化值为maxint
    def has_node(self,nodes):
        for node in nodes:
            if node not in self.dicts.keys():
                self.dicts[node] = self.maxint
                self.strList.append(node)
    # 添加数据
    def add(self,start:str,end:str,weight:int):
        # start:有向边起点；end：有向边的终点；weight:有向边的权重
        self.has_node([start,end])
        self.edges.append({
            'start':start,
            'end':end,
            'weight':weight
        })

定义初始化数据函数

    #开始初始化
    def init(self):
        for dict in self.dicts.keys():
            self.dicts[dict] = self.maxint
        self.dicts[self.startedvertex] = 0
        #字符排序
        for i in range(len(self.strList)):
            for j in range(i):
                if self.strList[i] < self.strList[j]:
                    temp = self.strList[i]
                    self.strList[i] = self.strList[j]
                    self.strList[j] = temp

开始计算最短边

    def start(self):
        flag = 'true'
        # 初始化其他有向边的权重
        for i in range(self.node_num-1):
            for edge in self.edges:
                # 松弛逼近，不断地选择一条边，做松弛改进操作，直到得出正确的解答
                if self.dicts[edge['end']] > self.dicts[edge['start']] + edge['weight']:
                    self.dicts[edge['end']] = self.dicts[edge['start']] + edge['weight']
            temp = self.dicts.copy()
            self.dictsList.append(temp)

        for edge in self.edges:
            #判断是否存在负权回路的情况
            if self.dicts[edge['end']] > self.dicts[edge['start']] + edge['weight']:
                flag = 'false'
                break

        return {
            'dictsList':self.dictsList,
            'flag':flag
        }

调用算法类

if __name__ == "__main__":
	#Input格式：Nodenumber;startedvertex;edge,edge,weight;edge,edge,weight;…
    inp = input()
    inplist = inp.split(';')
    bf = None
    for i in range(len(inplist)):
        if i == 1:
            bf = Bellman_ford(node_num=int(inplist[0]), startedvertex=inplist[1])
        elif i > 1:
            inpstr = inplist[i].split(',')
            bf.add(start=inpstr[0],end=inpstr[1],weight=int(inpstr[2]))
    bf.init()
    rt = bf.start()
    #Output格式：node;node;node;…… distance;distance;distance;....... distance;distance;distance;.......如果為無限，輸出 inf (例如 : 0;8;2;inf;inf)
    print(";".join(["%s" %bf.strList[i] for i in range(len(bf.strList))]))
    for i in range(len(rt['dictsList'])):
        print(";".join(["%s" % rt['dictsList'][i][bf.strList[j]] for j in range(len(bf.strList))]))
    print(rt['flag'])