最短路径算法(Dijkstra, Bellman-Ford, Floyd-Warshall)-python实现

Dijkstra：

Inf = float('inf')

Adjacent = [[0, 1, 12, Inf, Inf, Inf],
            [Inf, 0, 9, 3, Inf, Inf],
            [Inf, Inf, 0, Inf, 5, Inf],
            [Inf, Inf, 4, 0, 13, 15],
            [Inf, Inf, Inf, Inf, 0, 4],
            [Inf, Inf, Inf, Inf, Inf, 0]]

src, dst, N = 0, 5, 6

def dijstra(adj, src, dst, n):
    dist = [Inf] * n
    dist[src] = 0
    book = [0] * n
    u = src
    for _ in range(n-1):
        book[u] = 1
        next_u, minVal = None, float('inf')
        for v in range(n):
            if not book[v] and adj[u][v] + dist[u] < dist[v]:
                dist[v] = adj[u][v] + dist[u]
                if dist[v] < minVal:
                    next_u, minVal = v, dist[v]
        u = next_u
    return dist

print(dijstra(Adjacent, src, dst, N))

Bellman-Ford：

INF = float('inf')

def Bellman_Ford(Graph, start, n):
    
    D = [INF] * n
    Pr = [-1] * n
    D[start] = 0

    # 初始化结束, 开始循环
    for _ in range(0,n-1):
        for k in range(n):
            for j in range(n):
                if(D[k] > D[j] + Graph[j][k]):
                    D[k] = D[j] + Graph[j][k]
                    Pr[k] = j
    return D

Graph = [[0, 1, 5, 3, INF],
         [INF, 0, 2, INF, INF],
         [INF, INF, 0, -4, INF],
         [INF, INF, INF, 0, 3],
         [INF, 2, INF, INF, 0]]

print(Bellman_Ford(Graph, 0, 5))

Floyd-Warshall：

INF = float('inf')

Graph = [
    [0, 2, 6, 4],
    [INF, 0, 3, INF],
    [7, INF, 0, 1],
    [5, INF, 12, 0]
]

def floyd(Graph, n):
    for k in range(n):
        for i in range(n):
            for j in range(n):
                if Graph[i][j] > Graph[i][k] + Graph[k][j]:
                    Graph[i][j] = Graph[i][k] + Graph[k][j]
    return Graph

print(floyd(Graph, 4))