python數據結構與算法——圖的最短路徑（Bellman-Ford算法）解決負權邊

# Bellman-Ford核心算法
# 對於一個包含n個頂點，m條邊的圖, 計算源點到任意點的最短距離
# 循環n-1輪，每輪對m條邊進行一次松弛操作

# 定理：
# 在一個含有n個頂點的圖中，任意兩點之間的最短路徑最多包含n-1條邊
# 最短路徑肯定是一個不包含回路的簡單路徑（回路包括正權回路與負權回路）
# 1. 如果最短路徑中包含正權回路，則去掉這個回路，一定可以得到更短的路徑
# 2. 如果最短路徑中包含負權回路，則每多走一次這個回路，路徑更短，則不存在最短路徑
# 因此最短路徑肯定是一個不包含回路的簡單路徑，即最多包含n-1條邊，所以進行n-1次松弛即可


G = {1:{1:0, 2:-3, 5:5},
     2:{2:0, 3:2},
     3:{3:0, 4:3},
     4:{4:0, 5:2},
     5:{5:0}}



def getEdges(G):
    """ 輸入圖G，返回其邊與端點的列表 """
    v1 = []     # 出發點         
    v2 = []     # 對應的相鄰到達點
    w  = []     # 頂點v1到頂點v2的邊的權值
    for i in G:
        for j in G[i]:
            if G[i][j] != 0:
                w.append(G[i][j])
                v1.append(i)
                v2.append(j)
    return v1,v2,w

class CycleError(Exception):
    pass

def Bellman_Ford(G, v0, INF=999):
    v1,v2,w = getEdges(G)
    
    # 初始化源點與所有點之間的最短距離
    dis = dict((k,INF) for k in G.keys())
    dis[v0] = 0

    # 核心算法
    for k in range(len(G)-1):   # 循環 n-1輪
        check = 0           # 用於標記本輪松弛中dis是否發生更新
        for i in range(len(w)):     # 對每條邊進行一次松弛操作
            if dis[v1[i]] + w[i] < dis[v2[i]]:
                dis[v2[i]] = dis[v1[i]] + w[i]
                check = 1
        if check == 0: break
    
    # 檢測負權回路
    # 如果在 n-1 次松弛之后，最短路徑依然發生變化，則該圖必然存在負權回路
    flag = 0
    for i in range(len(w)):             # 對每條邊再嘗試進行一次松弛操作
        if dis[v1[i]] + w[i] < dis[v2[i]]: 
            flag = 1
            break
    if flag == 1:
#         raise CycleError()
        return False
    return dis

v0 = 1
dis = Bellman_Ford(G, v0)
print dis.values()