python 之弗洛伊德算法_floyd-warshall算法python代码

介绍

弗洛伊德算法，也称为Floyd-Warshall算法，是一种用于解决图中所有节点对之间的最短路径问题的动态规划算法。它可以处理带有负权边但不含负权环的加权有向图或无向图。该算法以Robert Floyd和Stephen Warshall的名字命名，于1962年分别由他们独立提出。

以下是弗洛伊德算法的详细步骤：

1. 初始化距离矩阵：创建一个二维数组dist[][]，其中dist[i][j]表示节点i到节点j的最短路径长度。如果节点i到节点j有直接连接的边，则dist[i][j]的值为这条边的权重；否则，dist[i][j]的值设为无穷大，表示不可达。

2. 初始化对角线：将对角线上的元素dist[i][i]设为0，表示每个节点到自身的距离为0。

3. 动态规划更新：对于每一对节点(i, j)，以每个节点k作为中间节点，检查是否存在一条从节点i到节点j的路径，经过节点k可以使得路径长度更短。如果存在这样的路径，则更新dist[i][j]为dist[i][k] + dist[k][j]，即通过中间节点k的路径长度。如果dist[i][k] + dist[k][j]比当前已知的dist[i][j]更小，则更新dist[i][j]。

4. 重复更新：重复以上步骤，直到所有节点对之间的最短路径都被找到，并且没有更改发生。最终，dist[][]矩阵中的值就是每对节点之间的最短路径长度。

弗洛伊德算法的时间复杂度为O(n^3)，其中n是图中的节点数。由于它使用了动态规划的思想，因此适用于解决小规模的图以及密集图。然而，对于大型稀疏图，可能会有更高效的算法，比如Dijkstra算法和Bellman-Ford算法，它们针对单源最短路径问题的性能更好。

代码

以下是使用Python实现弗洛伊德算法的代码示例：

INF = float('inf')

def floyd_warshall(graph):
    # 初始化距离矩阵
    dist = [[INF if i != j else 0 for j in range(len(graph))] for i in range(len(graph))]
    
    # 更新距离矩阵
    for i in range(len(graph)):
        for j in range(len(graph)):
            if graph[i][j] != 0:  # 如果节点i和节点j之间有直接连接的边
                dist[i][j] = graph[i][j]
    
    # 动态规划更新距离矩阵
    for k in range(len(graph)):
        for i in range(len(graph)):
            for j in range(len(graph)):
                if dist[i][k] != INF and dist[k][j] != INF:  # 如果节点i到k和k到节点j之间有路径
                    dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
    
    return dist

# 示例图的邻接矩阵表示
graph = [
    [0, 5, INF, 10],
    [INF, 0, 3, INF],
    [INF, INF, 0, 1],
    [INF, INF, INF, 0]
]

# 打印最短路径距离矩阵
result = floyd_warshall(graph)
for row in result:
    print(row)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

这段代码首先定义了一个INF常量，用于表示无穷大。然后实现了floyd_warshall函数，该函数接受一个邻接矩阵表示的图作为输入，并返回所有节点对之间的最短路径距离矩阵。在函数中，首先初始化距离矩阵，然后根据图的邻接矩阵更新直接连接的边的距离，接着使用动态规划的思想逐步更新距离矩阵，直到得到所有节点对之间的最短路径距离矩阵。

蓝桥公园

import os
import sys

# 请在此输入您的代码
N, M, Q = map(int, input().split())
weight = [[0 if i == j else sys.maxsize for i in range(N + 1) ] for j in range(N + 1)]  # 领接矩阵
for i in range(M):
    u, v, w = map(int, input().split())
    weight[u][v] = min(weight[u][v], w)
    weight[v][u] = weight[u][v]
for k in range(1, N + 1):  # N次递推
    for i in range(1, N + 1):
        for j in range(i + 1, N + 1):  # 更新最小值
                weight[i][j] = min(weight[i][j], weight[i][k] + weight[k][j])
                weight[j][i] = weight[i][j]

for i in range(Q):
    st, ed = map(int, input().split())
    t = weight[st][ed]
    if t == sys.maxsize:
        print(-1)
    else:
        print(t)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25