单源最短路径问题：Bellman-Ford算法

AKIKZ

已于 2024-05-19 17:31:37 修改

阅读量828

点赞数 25

分类专栏：单源最短路径问题文章标签： python

于 2024-05-19 16:50:57 首次发布

本文链接：https://blog.csdn.net/mmd666/article/details/139011019

版权

单源最短路径问题专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Bellman-Ford算法简介

Bellman-Ford算法是一种用于在加权图中找到单源最短路径问题的算法。它与Dijkstra算法不同，因为它可以处理负权边(允许边的权值为负数)，只要图中没有负权回路（详情见结尾）。如果存在负权回路，Bellman-Ford算法可以检测到这一点（迭代次数超过V-1次，就说明存在负权回路），一般用于实现通过m次迭代求出从起点到终点不超过m条边构成的最短路径。以下是Bellman-Ford算法的详细介绍：

算法原理

对图进行V-1次松弛操作（详情见结尾）（V为图中顶点的数量），得到所有可能的最短路径。在每次松弛操作中，算法会检查从源点到每个顶点的所有路径，并尝试通过更新路径的权值来找到更短的路径。

松弛操作

松弛操作是不断更新最短路径和前驱结点的过程。假设从源点s到顶点u的最短路径已知，且其长度为dis[u]（表示每个点到起点的距离），现在考虑从u出发的边(u, v)(从u出发，到v)，其权值为w。如果dis[u] + w < dis[v]，则更新dis[v]为dis[u] + w，并设置v的前驱结点为u。

算法步骤

1. 初始化：对于图中的每个顶点 v，设置距离 dist[v] 为无穷大（表示从源点到该顶点的距离未知），除了源点 s 的距离设为0。（与Dijkstra算法第一步一样）

2. 松弛操作：对于图中的每一条边，执行V-1次松弛操作。

3. 负权回路检测：如果在执行完V-1次松弛操作后，再进行一次松弛操作仍能找到更短的路径，则说明图中存在负权回路。

4. 输出：如果算法完成所有步骤而没有检测到负权回路，则 dist[] 数组包含了从源点 s 到所有其他顶点的最短路径长度。

算法特点

时间复杂度（详情见结尾）：O(V * E)（普遍高于Dijkstra算法O(N²)）（推理详情见结尾），其中 V 是顶点数，E 是边数。这使得它在处理大型图时可能效率较低。然而，通过一些优化技术（详情见结尾），可以提高算法的效率。
负权边：可以处理负权边，但不能有负权回路。
确定性：算法是确定性的，总是找到最短路径或报告负权回路的存在。

实例演示

让我们通过一个简单的示例来演示Bellman-Ford算法的工作原理。

假设我们的源节点是0，我们的目标是找到从0到所有点的最短路径。让我们用Bellman-Ford算法来解决这个问题。

步骤

1. 初始化距离：初始化距离数组 dist，大小为7（因为有7个顶点），除了 dist[0]（源点到自身的距离）为0，其他都设为 sys.maxsize（无穷大）。

2. 迭代过程：重复松弛边，直到没有边可以进一步松弛为止。执行 n-1（这里是6次）迭代，每次迭代都会检查所有边，并尝试更新顶点间的最短距离。

3. 检测负权回路：在 n-1 （这里是6次）次迭代后，再次检查图中的每一条边。在第n（这里是第7次）次检查中，如果发现任何距离可以被更新，则意味着存在负权回路。

4. 结束：dist 数组包含了从源点到每个顶点的最短路径长度。

Bellman-Ford算法流程

1.初始化

初始化距离数组 dist，将源点到自身的距离设为0，其他顶点到源点的距离设为无穷大（这里用一个大数表示，例如 float('inf')）或sys.maxsize。
graph = [
    [(1, 6)]            # 0 -> 1: 6
    [(0, -1), (2, 5)]  # 1 -> 0: -1, 1 -> 2: 5
    [(1, -2), (3, 4)]  # 2 -> 1: -2, 2 -> 3: 4
    [(2, -3), (4, 2), (5, -2)] # 3 -> 2: -3, 3 -> 4: 2, 3 -> 5: -2
    [(3, 3), (6, 2), (2, 1)]  # 4 -> 3: 3, 4 -> 6: 2, 4 -> 2: 1
    [(4, 5), (6, 3)]       # 5 -> 4: 5, 5 -> 6: 3
    [(5, 1), (4, 4)]       # 6 -> 5: 1, 6 -> 4: 4
]
source = 0  # 源点是顶点0
dist = [sys.maxsize] * (len(graph))

# dist = [float('inf')] * len(graph)  # 初始化距离数组

dist[source] = 0  # 源点到自身的距离是0
距离 0到自身为 0。
距离 1 为无穷大。
距离 2 为无穷大。
距离 3 为无穷大。
距离 4 为无穷大。
距离 5 为无穷大。
距离 6 为无穷大。
距离 7 为无穷大。

2.算法迭代过程
对于有 n 个顶点的图，算法需要进行 n-1 次迭代。在这个例子中，顶点数量是7，所以需要进行6次迭代。

迭代 1

更新顶点0的邻接点（顶点1）:
0 -> 1: dist[1] = min(dist[1], dist[0] + 6) = min(inf, 0 + 6) = 6

迭代 2

更新顶点1的邻接点（顶点0和顶点2）:
1 -> 0: 不更新，因为 dist[1] + (-1) = 6 - 1 = 5 不小于 dist[0] = 0
1 -> 2: dist[2] = min(dist[2], dist[1] + 5) = min(inf, 6 + 5) = 11

迭代 3

更新顶点2的邻接点（顶点1, 顶点3）:
2 -> 1: 不更新，因为 dist[2] + (-2) = 11 - 2 = 9 不小于 dist[1] = 6
2 -> 3: dist[3] = min(dist[3], dist[2] + 4) = min(inf, 11 + 4) = 15

迭代 4

更新顶点3的邻接点（顶点2, 顶点4, 和顶点5）:
3 -> 2: 不更新，因为 dist[3] + (-3) = 15 - 3 = 12 不小于 dist[2] = 11
3 -> 4: dist[4] = min(dist[4], dist[3] + 2) = min(inf, 15 + 2) = 17
3 -> 5: dist[5] = min(dist[5], dist[3] - 2) = min(inf, 15 + 2) = 13

迭代 5

更新顶点4的邻接点（顶点2, 顶点3, 和顶点6）:
4 -> 2: 不更新，因为 dist[4] + 1 = 17 + 1 = 18 不小于 dist[2] = 11
4 -> 3: 不更新，因为 dist[4] + 3 = 17 + 3 = 20 不小于 dist[3] = 15
4 -> 6: dist[6] = min(dist[6], dist[4] + 3) = min(17, 17 + 3) = 17 (保持不变)

迭代 6

更新顶点5的邻接点（顶点4 和顶点6）:
5 -> 4: 不更新，因为 dist[5] + 5 = 13 + 5 = 18 不小于 dist[4] = 17
5 -> 6: dist[6] = min(dist[6], dist[5] + 3) = min(17, 13 + 3) = 16

最后的结果
经过6次迭代后，我们得到以下距离数组 dist，表示从源点0到每个顶点的最短路径长度：

dist[0] = 0 (源点到自身的距离)
dist[1] = 6 (源点0到顶点1的距离)
dist[2] = 11 (源点0到顶点2的距离)
dist[3] = 15 (源点0到顶点3的距离)
dist[4] = 17 (源点0到顶点4的距离)
dist[5] = 13 (源点0到顶点5的距离)
dist[6] = 16 (源点0到顶点6的距离)

这些距离表示从源点0到图中每个顶点的最短路径的总权重。在这个例子中，没有检测到负权回路，因此这些结果是有效的最短路径长度。
# pip install sys

import sys

def bellman_ford(graph, source):

    # 初始化距离数组，所有节点到源节点的距离初始化为无穷大（除了源节点到自身的距离为0）

    dist = [sys.maxsize] * (len(graph))
    dist[source] = 0

    # 松弛所有边n-1次（n是图中节点的数量）

    for _ in range(len(graph) - 1):
        for u in range(len(graph)):
            for v, weight in graph[u]:

                # 如果通过u到达v的距离比当前已知的距离短，则更新距离

                if dist[u] != sys.maxsize and dist[u] + weight < dist[v]:
                    dist[v] = dist[u] + weight

    # 单独进行一次负权回路的检查
    for u in range(len(graph)):
        for v, weight in graph[u]:
            if dist[u] != sys.maxsize and dist[u] + weight < dist[v]:
                print("Graph contains a negative-weight cycle")
                return None

    return dist

# 以邻接列表形式表示
# 由于有负权回路，所以结果是

# Graph contains a negative-weight cycle
# No solution due to negative-weight cycle.

# graph = [
#     [(1, 6)],
#     [(0, -1), (2, 5)],
#     [(1, -2), (3, 4)],
#     [(2, -3), (4, 2), (5, -2)],
#     [(3, 3), (6, 2), (2, 1)],
#     [(4, 5), (6, -3)],
#     [(5, 1), (4, -4)]
# ]

# 没有负权重回路的邻接链表
graph = [
    [(1, 6)],
    [(0, -1), (2, 5)],
    [(1, -2), (3, 4)],
    [(2, -3), (4, 2), (5, -2)],
    [(3, 3), (6, 2), (2, 1)],
    [(4, 5), (6, 3)],
    [(5, 1), (4, 4)]
]


# 源节点
source = 0

# 计算最短路径
distances = bellman_ford(graph, source)

if distances is not None:
    for i, d in enumerate(distances):
        print(f"Distance from source {source} to node {i}: {d}")
    print("All distances:", distances)
else:
    print("No solution due to negative-weight cycle.")
如果你想读入自己的数据，则需要以下代码（读入你自己的xls文件并转换为邻接链表）
# pip install pandas openpyxl
import pandas as pd

def read_xlsx_to_adj_list(xlsx_file_path):
    # 读取xlsx文件
    df = pd.read_excel(xlsx_file_path)
    
    # 获取顶点列表和列名
    nodes = df.columns.tolist()
    
    # 初始化邻接链表，使用双层列表表示
    adj_list = {node: [] for node in nodes}
    
    # 遍历DataFrame中的每一行来构建邻接链表
    for index, row in df.iterrows():
        for node, edge in row.items():
            if not pd.isna(edge):  # 检查单元格是否为空
                # 假设Excel文件中边的格式为"目标节点,权重"
                target, weight = map(int, edge.split(','))
                # 将边添加到邻接链表中
                adj_list[nodes.index(node)].append((target, weight))
    
    return adj_list

# 用法示例
xlsx_file_path = 'path_to_your_file.xlsx'  # 替换为你的xlsx文件路径
adjacency_list = read_xlsx_to_adj_list(xlsx_file_path)

# 打印邻接链表
for node, edges in adjacency_list.items():
    print(f"Node {node}: {edges}")

注意事项

如果图中存在负权回路，Bellman-Ford算法可以检测到它，但不能找到最短路径。
对于没有负权回路的图，Bellman-Ford算法可以找到所有顶点的最短路径。
该算法不适用于稀疏图，因为它的时间复杂度较高。

Bellman-Ford算法是图算法中的一个重要工具，尤其是在需要处理负权边的情况下。然而，对于没有负权边的图，通常会优先考虑使用更高效的算法，如Dijkstra算法。

负权回路

负权回路是指在图论中，存在一条闭合路径，其边的权重之和为负值。在最短路径问题中，如果存在负权回路，那么最短路径问题就没有确定的解，因为可以通过不断重复经过这条负权回路来无限地减少路径的总权重。

在有向图中，如果存在负权回路，那么可以利用贝尔曼-福特算法（Bellman-Ford algorithm）来检测它。贝尔曼-福特算法通过迭代地更新路径权重来寻找从单一源点到所有其他顶点的最短路径。如果在经过所有顶点的迭代之后，仍然可以找到更短的路径，那么就可以确定图中存在负权回路。

在无向图中，由于边是双向的，通常不存在负权回路，因为如果一条边的权重为负，那么它的反向边的权重必然为正，两者相加权重为零，不会产生负权重的闭合路径。

负权回路的存在对许多图算法都有重要影响，例如在网络流问题和一些优化问题中，负权回路可能会使得问题变得无解或者需要特殊的处理方法。

当图中存在负权回路时，最短路径可能不存在，因为可以不断地通过这个负权回路来减少路径的总权重，从而使得路径的权重无限减小，无法达到一个最小值。以下是详细解释和例子：

为什么最短路径不一定存在：

1. 权重无限减小：如果一条路径中包含负权回路，那么可以重复经过这个回路来无限减小总路径权重。因为每次经过这个回路，路径的总权重都会减少，所以理论上可以无限次地重复这个过程，导致路径权重无限减小。

2. 违反三角不等式：在没有负权回路的情况下，图的边权重满足三角不等式，即从一个点到另一个点的直接边的权重不大于通过第三个点的间接路径权重。但是，如果存在负权回路，那么三角不等式会被违反，因为通过负权回路的间接路径权重可以小于直接边的权重。

例子：

考虑以下有向图，其中包含一个负权回路：

在这个图中，从A到B的边权重为1，从B到C的边权重为2，从C回到A的边权重为-5。现在考虑从A到A的闭合路径：

第一次经过这个回路：A -> B -> C -> A，总权重为 1 + 2 - 5 = -2。
第二次经过这个回路：A -> B -> C -> A -> B -> C -> A，总权重为 -2 + 1 + 2 - 5 = -4。

可以看到，每次经过这个负权回路，路径的总权重都会减少。如果我们继续这个过程，路径的总权重可以无限减小，因此不存在一个确定的最短路径。

结论：

由于可以无限地通过负权回路来减少路径的总权重，所以如果图中存在负权回路，最短路径问题就没有确定的解。这与没有负权回路的情况形成对比，在没有负权回路的情况下，最短路径问题可以通过如Dijkstra算法等方法来解决，因为这些算法基于三角不等式来保证找到的路径是最短的。

处理负权回路的算法：

1. 贝尔曼-福特算法（Bellman-Ford Algorithm）：这是一种动态规划算法，可以处理图中的负权边和负权回路。算法的核心是进行多次松弛操作，每次迭代都考虑所有边，如果通过某条边可以找到更短的路径，则更新这条路径。贝尔曼-福特算法可以检测图中是否存在负权回路，如果存在，算法将无法得到有效的最短路径解。

2. SPFA算法（Shortest Path Faster Algorithm）：这是贝尔曼-福特算法的一个优化版本，它使用队列来优化松弛操作，减少不必要的迭代。SPFA算法在稀疏图上的性能优于贝尔曼-福特算法，并且同样可以处理负权边和负权回路。

3. Floyd-Warshall算法：虽然Floyd-Warshall算法主要用于计算图中所有顶点对的最短路径，但它也可以处理负权边。然而，如果图中存在负权回路，算法将无法得到有效的最短路径解，因为负权回路可以无限减小路径的权重。

4. Johnson算法：Johnson算法是一种结合了贝尔曼-福特算法和Dijkstra算法的算法，它可以处理带有负权边的图。它首先使用贝尔曼-福特算法来重新加权图，然后使用Dijkstra算法来找到所有顶点对的最短路径。

需要注意的是，虽然有些算法可以处理负权边，但如果图中存在负权回路，那么最短路径问题可能就没有确定的解，因为可以通过不断经过负权回路来无限减小路径权重。在这种情况下，算法可能无法找到有效的最短路径，或者需要特殊的处理方法来应对负权回路的存在。

松弛操作

松弛操作（Relaxation）是图论中解决最短路径问题的一种基本技术，特别是在动态规划和贝尔曼-福特算法中。松弛操作的目的是更新从一个顶点到另一个顶点的最短路径估计。

松弛操作的步骤：

1. 选择一条边：选择图中的一条边，这条边连接两个顶点，记为 u 和 v 。

2. 检查权重：检查这条边的权重 w(u, v) 是否比当前已知的从 u 到 v 的路径权重 dist[v] 更小。

3. 更新路径权重：如果 w(u, v) + dist[u] < dist[v] ，那么更新 dist[v] 为 w(u, v) + dist[u] 。这意味着通过边 (u, v) 到达 v 的新路径比已知的路径更短。

4. 重复操作：对图中的所有边重复这个过程，直到没有更多的边可以更新路径权重为止。

为什么松弛操作是必要的：

寻找最短路径：松弛操作帮助算法找到从源点到图中所有其他顶点的最短路径。
处理负权边：在有负权边的情况下，松弛操作是必要的，因为它们可能会影响最短路径的计算。
动态更新：通过不断松弛边，算法能够动态地更新对最短路径的估计，直到收敛到正确的最短路径。

贝尔曼-福特算法中的松弛操作：

贝尔曼-福特算法是一种特殊的最短路径算法，它可以处理负权边和负权回路。算法的核心就是重复进行松弛操作：

1. 初始化距离：将源点到所有其他顶点的距离初始化为无穷大（或一个非常大的数），将源点到自身的距离初始化为0。

2. 进行松弛操作：对图中的每一条边，执行松弛操作，更新从源点到图中所有顶点的距离。

3. 迭代：重复步骤2，直到没有更多的边可以更新距离，或者达到某个预定的迭代次数。

4. 检测负权回路：在所有顶点上重复执行松弛操作 |V| - 1 次，其中 |V| 是顶点的数量。如果在 |V| - 1 次迭代后仍然可以更新距离，这意味着存在一个负权回路。

通过这种方式，贝尔曼-福特算法不仅可以找到最短路径，还可以检测图中是否存在负权回路。如果存在负权回路，算法将无法得到有效的最短路径解。

时间复杂度

时间复杂度是计算机科学中用来描述算法运行时间与输入规模之间关系的量度。它通常用来比较不同算法的效率，特别是在输入规模增大时，算法运行时间增长的快慢。时间复杂度通常用大O符号表示，它可以将算法的运行时间表示为输入规模的一个函数。（时间复杂度越低，程序运行所用的时间越少）

时间复杂度的常见分类：

1. 常数时间复杂度 O(1)：算法的运行时间与输入规模无关，无论输入大小如何，运行时间都是固定的。

2. 对数时间复杂度 O(log n)：算法的运行时间与输入规模的对数成正比。对数时间复杂度通常出现在需要不断分割数据集的算法中，如二分搜索。

3. 线性时间复杂度 O(n)：算法的运行时间与输入规模成正比。每个输入元素都需要执行一个固定时间的操作。

4. 线性对数时间复杂度 O(n log n)：这是许多高效的排序算法的时间复杂度，如快速排序、归并排序和堆排序。

5. 平方时间复杂度 O(n^2)：算法的运行时间与输入规模的平方成正比。这种复杂度通常出现在两层循环的算法中。

6. 指数时间复杂度 O(2^n)：算法的运行时间与输入规模的指数成正比。这类算法在问题规模增大时非常慢，通常不适用于大规模问题。

7. 多项式时间复杂度 O(n^k)：算法的运行时间是输入规模的多项式函数，其中 k 是一个常数。多项式时间复杂度通常被认为是“有效”的，因为随着输入规模的增加，运行时间的增长是可控的。

8. 非多项式时间复杂度：如果时间复杂度不是多项式形式，如 O(2^n) 或 O(n!)，那么这类算法通常被认为是低效的，因为它们在问题规模增大时运行时间增长非常快。

时间复杂度的计算：

最坏情况分析：通常考虑算法在最坏情况下的时间复杂度，即假设输入数据会导致最长的运行时间。
平均情况分析：有时也会考虑算法的平均时间复杂度，这需要对所有可能的输入进行平均。
最佳情况分析：在某些情况下，也会考虑算法在最佳情况下的时间复杂度，即假设输入数据会导致最短的运行时间。

时间复杂度是算法分析中的一个重要概念，它帮助我们理解和比较不同算法的效率，尤其是在处理大规模数据时。

Bellman-Ford算法的时间复杂度

以下是Bellman-Ford算法的基本步骤：

1. 初始化：将所有顶点到源点的距离设置为无穷大（或者一个非常大的数），除了源点自身到自己的距离设置为0。

2. 松弛操作：对图中的每一条边进行松弛操作，即检查通过这条边是否可以找到从源点到当前顶点更短的路径。如果可以通过边 (u, v) 找到更短的路径，则更新从源点到顶点 v 的距离。

3. 迭代：重复步骤2，直到没有更多的边可以进行松弛操作，或者达到一个预定的迭代次数。

Bellman-Ford算法的时间复杂度主要由以下因素决定：

边的数量：算法需要对每条边执行松弛操作。
迭代次数：算法需要进行多次迭代，直到所有边都无法进一步松弛。

对于有 V 个顶点和 E 条边的图，Bellman-Ford算法的时间复杂度分析如下：

松弛操作：在最坏的情况下，每条边都需要被检查 V-1 次，因为从源点出发，最长的简单路径（不重复顶点的路径）可以包含 V-1 条边。因此，松弛操作的总次数为 E* (V-1)。
初始化：初始化所有顶点到源点的距离可以在 O(V) 时间内完成。
迭代：算法需要进行 V-1 次迭代，每次迭代都需要执行所有的松弛操作。

综合以上因素，Bellman-Ford算法的时间复杂度为 O(VE)。这是因为算法的主要工作量在于对每条边进行 V-1 次松弛操作，而每次迭代中的松弛操作数量与边的数量成正比。

需要注意的是，尽管 O(VE) 是Bellman-Ford算法的理论时间复杂度，但在实际应用中，算法的效率可能会因为图的结构和特定实现而有所不同。例如，在稀疏图上，边的数量 E 远小于 V^2，这时算法的效率会相对较高。