【算法——Python实现】有负权图求单源最短路径BellmanFord算法

class Edge(object):
"""边"""
def __init__(self, a, b, weight):
self.a = a # 第一个顶点
self.b = b # 第二个顶点
self.weight = weight # 权值

def v(self):
return self.a

def w(self):
return self.b

def wt(self):
return self.weight

def other(self, x):
# 返回x顶点连接的另一个顶点
if x == self.a or x == self.b:
if x == self.a:
return self.b
else:
return self.a

def __lt__(self, other):
# 小于号重载
return self.weight < other.wt()

def __le__(self, other):
# 小于等于号重载
return self.weight <= other.wt()

def __gt__(self, other):
# 大于号重载
return self.weight > other.wt()

def __ge__(self, other):
# 大于等于号重载
return self.weight >= other.wt()

def __eq__(self, other):
# ==号重载
return self.weight == other.wt()

class DenseGraph(object):
"""有权稠密图 - 邻接矩阵"""
def __init__(self, n, directed):
self.n = n  # 图中的点数
self.m = 0  # 图中的边数
self.directed = directed  # bool值，表示是否为有向图
self.g = [[None for _ in range(n)] for _ in range(n)]  # 矩阵初始化都为None的二维矩阵

def V(self):
# 返回图中点数
return self.n

def E(self):
# 返回图中边数
return self.m

def addEdge(self, v, w, weight):
# v和w中增加一条边，v和w都是[0,n-1]区间
if v >= 0 and v < n and w >= 0 and w < n:
if self.hasEdge(v, w):
self.m -= 1
self.g[v][w] = Edge(v, w, weight)
if not self.directed:
self.g[w][v] = Edge(w, v, weight)
self.m += 1

def hasEdge(self, v, w):
# v和w之间是否有边，v和w都是[0,n-1]区间
if v >= 0 and v < n and w >= 0 and w < n:
return self.g[v][w] != None

class adjIterator(object):
"""相邻节点迭代器"""
def __init__(self, graph, v):
self.G = graph  # 需要遍历的图
self.v = v  # 遍历v节点相邻的边
self.index = 0  # 遍历的索引

def __iter__(self):
return self

def next(self):
while self.index < self.G.V():
# 当索引小于节点数量时遍历，否则为遍历完成，停止迭代
if self.G.g[self.v][self.index]:
r = self.G.g[self.v][self.index]
self.index += 1
return r
self.index += 1
raise StopIteration()

class SparseGraph(object):
"""有权稀疏图- 邻接表"""
def __init__(self, n, directed):
self.n = n  # 图中的点数
self.m = 0  # 图中的边数
self.directed = directed  # bool值，表示是否为有向图
self.g = [[] for _ in range(n)]  # 矩阵初始化都为空的二维矩阵

def V(self):
# 返回图中点数
return self.n

def E(self):
# 返回图中边数
return self.m

def addEdge(self, v, w, weight):
# v和w中增加一条边，v和w都是[0,n-1]区间
if v >= 0 and v < n and w >= 0 and w < n:
# 考虑到平行边会让时间复杂度变为最差为O(n)
# if self.hasEdge(v, w):
#   return None
self.g[v].append(Edge(v, w, weight))
if v != w and not self.directed:
self.g[w].append(Edge(w, v, weight))
self.m += 1

def hasEdge(self, v, w):
# v和w之间是否有边，v和w都是[0,n-1]区间
# 时间复杂度最差为O(n)
if v >= 0 and v < n and w >= 0 and w < n:
for i in self.g[v]:
if i.other(v) == w:
return True
return False

class adjIterator(object):
"""相邻节点迭代器"""
def __init__(self, graph, v):
self.G = graph  # 需要遍历的图
self.v = v  # 遍历v节点相邻的边
self.index = 0  # 遍历的索引

def __iter__(self):
return self

def next(self):
if len(self.G.g[self.v]):
# v有相邻节点才遍历
if self.index < len(self.G.g[self.v]):
r = self.G.g[self.v][self.index]
self.index += 1
return r
else:
raise StopIteration()
else:
raise StopIteration()

class ReadGraph(object):
"""读取文件中的图"""
def __init__(self, graph, filename):
with open(filename, 'r') as f:
line = f.readline()
line = line.strip('\n')
line = line.split()
v = int(line[0])
e = int(line[1])
if v == graph.V():
lines = f.readlines()
for i in lines:
a, b, w = self.stringstream(i)
if a >= 0 and a < v and b >=0 and b < v:
g
be0b
raph.addEdge(a, b, w)

def stringstream(self, text):
result = text.strip('\n')
result = result.split()
a, b, w = result
return int(a), int(b), int(w)

class BellmanFord(object):
"""BellmanFord求单源最短路径，可以有负权值。多次执行松弛操作，一点到一点最短路径最多有V-1条边V个顶点，松弛时超过这个数则证明有负权环，无最短路径
只能处理有向图，无向图如果两个点之间权值都为负会直接形成负权环"""
def __init__(self, graph, s):
self.G = graph  # 图
self.s = s  # 原点s
self.distTo = [0 for _ in range(self.G.V())]  # 从原点到每个节点的权值，初始都为0
self.fromed = [None for _ in range(self.G.V())] # 记录此节点来自哪个节点的连接，存储边。None表示未被访问过
self.hasNegativeCircle = False  # 是否有负权环

# BellmanFord
# 共对所有顶点做V-1次松弛
for p in range(self.G.V()-1):
# 每一轮松弛要对所有节点都做松弛操作
for i in range(self.G.V()):
# 只对原点s或者其他已经到达的顶点做松弛操作
if self.fromed[i] or self.s == i:
adj = self.G.adjIterator(self.G, i)
for e in adj:
# 如果w还未被访问过，或经过v的最短路径再到w节点的权值小于w之前被访问时记录的路径，则用经过v再到w的路径替代
if not self.fromed[e.w()] or self.distTo[i] + e.wt() <  self.distTo[e.w()]:
self.distTo[e.w()] = self.distTo[i] + e.wt()
self.fromed[e.w()] = e

self.hasNegativeCircle = self.detectNegativeCircle()

def detectNegativeCircle(self):
# 再做一轮对所有顶点的松弛操作，如果还能松弛则表示有负权环
for i in range(self.G.V()):
# 只对原点s或者其他已经到达的顶点做松弛操作
if self.fromed[i] or self.s == i:
adj = self.G.adjIterator(self.G, i)
for e in adj:
# 如果w还未被访问过，或经过v的最短路径再到w节点的权值小于w之前被访问时记录的路径，则表示一定有负权环
if not self.fromed[e.w()] or self.distTo[i] + e.wt() <  self.distTo[e.w()]:
return True
return False

def negativeCycle(self):
# 查询是否有负权环
return self.hasNegativeCircle

def shortestPathTo(self, w):
# 从原点到w节点的权值
if not self.hasNegativeCycle and w >= 0 and w < self.G.V():
return self.distTo[w]
else:
return None

def hasPathTo(self, w):
# 从原点到w是否有路径
if w >= 0 and w < self.G.V():
return self.fromed[w] != None

def shortestPath(self, w):
# 从原点到w的最短路径
if not self.hasNegativeCycle and w >= 0 and w < self.G.V():
s = []
e = self.fromed[w]
while e:
s.append(e)
e = self.fromed[e.v()]
s.reverse()
return s
else:
return None

def showPath(self, w):
# 输出路径
if not self.hasNegativeCycle and w >= 0 and w < self.G.V():
s = self.shortestPath(w)
i = 0
while i < len(s):
print s[i].v()
if i == len(s) - 1:
print s[i].w()
i += 1