迪杰斯特拉与贝尔曼福特

算法备考自用。

迪杰斯特拉

step1：初始化

• 设定起始节点为源节点，记为 s。
• 创建一个集合 S，用于存储已经确定最短路径的节点，初始时只有源节点 s。
• 创建一个距离数组 dist[]，其中 dist[s]=0（源节点到自身的距离为0），对于所有其他节点 v，设 dist[v]= 无穷大。
• 使用一个优先队列（或最小堆）来存储节点和当前的最短路径估计值

graph = [
    [0, 7, 9, 0, 0, 14],
    [7, 0, 10, 15, 0, 0],
    [9, 10, 0, 11, 0, 2],
    [0, 15, 11, 0, 6, 0],
    [0, 0, 0, 6, 0, 9],
    [14, 0, 2, 0, 9, 0]
]
def dijkstra(start):
    n = len(graph)
    distances =[float('inf')] * n
    distances[start] = 0
    priority_queue = [(0, start)] #(距离，节点）

step2：迭代过程

• 从优先队列中找出距离最小的节点u
• 将节点u加入集合S，表示当前节点最短路径已确定
• 遍历u的每个邻接节点v：

        计算alt = dist[u] + weight[u, v]; 当alt < dist[v]，则更新dist[v], 并将v和新距离丢进优先队列

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        # 当前距离大于node最小距离，直接拜拜
        if current_distance > distances[current_node]:
            continue

        # 能往下走说明，current_node的最短距离已经确定，相当于加入S那一步
        # 遍历该节点的邻接节点
        for i in range(n):
            if graph[current_node][i] > 0:
                distance = current_distance + graph[current_node][i]
                if distance < distances[i]:
                    distances[i] = distance
                    heapq.heappush(priority_queue, distances[i])

完整代码如下：

import heapq
# 示例图
graph = [
    [0, 7, 9, 0, 0, 14],
    [7, 0, 10, 15, 0, 0],
    [9, 10, 0, 11, 0, 2],
    [0, 15, 11, 0, 6, 0],
    [0, 0, 0, 6, 0, 9],
    [14, 0, 2, 0, 9, 0]
]
def dijkstra(start):
    n = len(graph)
    distances =[float('inf')] * n
    distances[start] = 0
    priority_queue = [(0, start)] #(距离，节点）

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        # 当前距离大于node最小距离，直接拜拜
        if current_distance > distances[current_node]:
            continue

        # 能往下走说明，current_node的最短距离已经确定，相当于加入S那一步
        # 遍历该节点的邻接节点
        for i in range(n):
            if graph[current_node][i] > 0:
                distance = current_distance + graph[current_node][i]
                if distance < distances[i]:
                    distances[i] = distance
                    heapq.heappush(priority_queue, distances[i])

    return distances

贝尔曼福特：

这玩意是针对有负权重的边的，具体原理可以参考以下视频：
【最短路径（二）Bellman-Ford算法-哔哩哔哩】 https://b23.tv/7jG9IAi

step1：初始化

创建距离数组dist[],初始化为无穷大，起始节点距离设置为0

    n = len(graph)
    dist = ['inf'] * n
    dist[start] = 0

step2：松弛操作（最多v-1次）

若dist[u] + v < dist[v]，更新dist[v];每轮有一个节点的值变了，就要再来一轮，当然这一步可以偷懒

    for _ in range(n - 1):
        for u in range(n):
            for v in range(n):
                if graph[u][v] != 0: # 说明有边，当然没这句话也可以
                    if dist[v] > dist[u] + graph[u][v]:
                        dist[v] = dist[u] + graph[u][v]

step3：检测是否有负环：

再来一次松弛，还有节点变化了，说明有负环，无解

for u in range(n):
    for v in range(n):
        if dist[v] > dist[u] + graph[u][v]:
            print("有坏人")
            return None

完整代码

graph = [
    [0, 4, 1, 0],
    [0, 0, 0, 1],
    [0, -2, 0, 5],
    [0, 0, 0, 0]
]
def bellman_ford(start):
# 初始化
    n = len(graph)
    dist = ['inf'] * n
    dist[start] = 0
# v-1次松弛
    for _ in range(n - 1):
        for u in range(n):
            for v in range(n):
                if graph[u][v] != 0:
                    if dist[v] > dist[u] + graph[u][v]:
                        dist[v] = dist[u] + graph[u][v]
# 检测负环
    for u in range(n):
        for v in range(n):
            if dist[v] > dist[u] + graph[u][v]:
                print("有坏人")
                return None

    return dist