Dijkstra算法

一、介绍

Dijkstra算法是一种流行的最短路径算法，用于计算机科学和图论中。它由荷兰计算机科学家Edsger W. Dijkstra在1956年发明，用于在图中查找两个节点之间的最短路径。

该算法通过维护源节点和图中所有其他节点之间的暂定距离列表来工作。然后，它选择具有最小暂定距离的节点，并更新其相邻节点的暂定距离。这个过程一直持续到算法访问了图中所有节点或到达了目标节点为止。

Dijkstra算法适用于具有非负权重的图，这意味着图中的所有边缘必须具有正数或零的权重。如果图具有负权重，则应使用不同的算法，例如Bellman-Ford算法。

Dijkstra算法的时间复杂度为O（E + V log V），其中E是图中的边数，V是节点数。它可以使用各种数据结构实现，例如优先队列，堆和数组。

二、代码实现 python

import heapq

def dijkstra(graph, start):
    # 初始化距离和前驱节点字典
    dist = {node: float('inf') for node in graph}
    prev = {node: None for node in graph}
    # 将起始节点距离设置为0
    dist[start] = 0
    # 创建堆，并将起始节点添加到其中
    heap = [(0, start)]
    # 当堆非空时，持续执行循环
    while heap:
        # 从堆中弹出距离最短的节点
        (curr_dist, curr_node) = heapq.heappop(heap)
        # 如果该节点已经被处理，则跳过它
        if curr_dist > dist[curr_node]:
            continue
        # 遍历该节点的所有相邻节点，并更新其距离和前驱节点
        for neighbor, weight in graph[curr_node].items():
            distance = curr_dist + weight
            if distance < dist[neighbor]:
                dist[neighbor] = distance
                prev[neighbor] = curr_node
                # 将该节点和其距离添加到堆中
                heapq.heappush(heap, (distance, neighbor))
    # 返回距离和前驱节点字典
    return dist, prev
graph = {
    'A': {'B': 2, 'C': 1},
    'B': {'A': 2, 'D': 3, 'E': 2},
    'C': {'A': 1, 'F': 5},
    'D': {'B': 3},
    'E': {'B': 2, 'F': 3},
    'F': {'C': 5, 'E': 3}
}

# 计算最短路径
dist, prev = dijkstra(graph, 'A')
# 输出结果
print(dist)
print(prev)

###
输出结果：
{'A': 0, 'B': 2, 'C': 1, 'D': 5, 'E': 4, 'F': 6}
{'A': None, 'B': 'A', 'C': 'A', 'D': 'B', 'E': 'B', 'F': 'C'}


###

这些结果告诉我们，从起始节点A到其他节点的最短距离分别是：

A到A的最短距离是0。
A到B的最短距离是2。
A到C的最短距离是1。
A到D的最短距离是5。
A到E的最短距离是4。
A到F的最短距离是5。

同时，它们的前驱节点分别是：

A的前驱节点是None。
B的前驱节点是A。
C的前驱节点是A。
D的前驱节点是B。
E的前驱节点是B。
F的前驱节点是C。

这些结果表明，从起始节点A到其他节点的最短路径分别是：

A
A → B
A → C
A → B → D
A → B → E
A → C → F