bellman是什么意思,bellman方程
文章目录大蟒代码：结果：概述了解过程：一个长示例：正确性：
大蟒代码：代码分别基于顶点（节点)集和边集
导入数学
将日志记录作为l导入
基本配置（级别=信息)
类边缘():
def __init__(自身，开始，结束，权重):
self.start=开始
self.end=结束
自重=重量
类节点():
def __init__(self，sign):
# self.number=数字
自我符号=符号
#表示图形的初始节点（顶点)
self.distance=math.inf
#设置节点的前身：
自身前驱=无
定义初始化源节点（自身):
self.distance=0
回归自我
G类():
s _ node=无
def __init__(自身，边，节点):
自我边缘=边缘
self.nodes=节点
# def生成节点(自身):
# #获取节点编号（您可以自定义编号规则，这里使用默认的简单编号系统)
#自我。nodes=[Node(chr(sign))for sign in range(ord( A )，ord(E) 1)]
定义日志_打印_节点（自身):
对于自我节点中的节点：
我。调试(f"{ node。符号，node.distance}”)
定义重量（自身、u、v):
对于自我边缘中的边：
如果edge.start==u且edge.end==v:
返回边缘。重量
返回math.inf
定义放松（自我，边缘):
u=边缘。开始
v=边缘。结束
l.debug(fself.weight(u，v):{self.weight(u，v)} )
新距离=u。距离自重(u，v)
#调试
我。调试(f"{ edge。开始吧。sign，edge.end.sign} ")
调试(f 新距离：{新距离} )
如果距离新距离：
距离=新距离
五。前体=u
# def初始化_单个_源(G，源节点):
# #用于g .节点中的节点：
# # node.distance=0
# # node.precursor=无
#源节点距离=0
极好的贝尔曼_福特(自我，s):
g。s节点=s . initialize _ source _ node()
我。信息(f g . s _ node:{ g . s _ node。符号} )
对于范围内的我(len(self。节点)-1):
对于自我边缘中的边：
自我放松（边缘)
我。调试(f"{ edge。结束。距离}”)
#调试
self.log_print_nodes()
回归自我
def打印_福特_结果(自身):
# self.bellman_ford
if not self.is_exist_shortest():
打印(有一个负循环。)
否则：
对于自我节点中的节点：
# print()
打印(f 到节点：{node.sign}，距离为：{node.distance} )
def is _ exist _ shortest(自身):
对于自我边缘中的边：
if edge.end.distance edge.start。距离边缘.重量：
返回错误的
返回真实的
定义打印_前驱(自身，节点):
如果node.sign==G.s_node.sign:
print(G.s_node.sign，end= )
#返回
否则：
如果node.precursor==无：
print(G.s_node.sign，-，node.sign，(节点不可访问)，end= )
否则：
自我。print _ precursor(节点。前驱)
print(node.sign，end= )
定义打印路径（自身):
对于自我节点中的节点：
#打印(节点.符号)
self.print _ precursor(节点)
打印()
极好的生成节点():
#获取节点编号（您可以自定义编号规则，这里使用默认的简单编号系统)
nodes=[Node(chr(sign))for sign in range(ord( A )，ord(E) 1)]
返回节点
#调试：打印节点：
def print_nodes():
对于节点中的节点：
打印（节点。符号，节点。距离)
# print_nodes()
def get_node_instance(符号):
对于节点中的节点：
如果node.sign==sign:
返回节点
#抛出异常
不返回
#获取边参数来实例化边节点，把边放到边列表中；
def generate_edges():
while(True):
line=input(输入节点：)
如果line==0 :
破裂
edge_param=line.split(，)
开始，结束，权重=边缘参数[0]，边缘参数[1]，整数(边缘参数[2])
开始节点=获取节点实例(开始)
end_node=get_node_instance(end)
#打印(结束节点符号)
edges.append(Edge(开始节点，结束节点，权重))
返回边缘
调试边缘是正确的：
def print_edges():
对于边中的边：
# print(edge.start.sign，edge.end.sign，edge.weight)
l.info((edge.start.sign，edge.end.sign，edge.weight))
# print_edges()
节点=[]
nodes=generate_nodes()
edges=[]
edges=generate_edges()
G=G(边，节点)
# G.print_nodes()
源节点=输入(输入您想要的源节点：(从 A E )\ n )
g。贝尔曼_福特（获取节点实例（源节点))
G.print_ford_result()
G.print_path()
测试数据：
a，B，-1
a，C，4
b，C，3
华盛顿特区，5
d，B，1
b，D，2
b，E，2
e，D，-3
0
结果：来源A:
来源D:
概观
了解流程：
一个很长的例子：
正确性：
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。