Dijkstra与Bellman-Ford算法：最短路径核心原理与工程选型指南

1. 从“找路”到“算路”：为什么我们需要最短路径算法

上次我们聊了图的基本概念和遍历方法，算是把“地图”给看明白了。但光会看地图没用，你得知道怎么从A点最快地走到B点。这就像你用导航软件，输入起点和终点，它瞬间就能给你规划出最优路线，避开拥堵，省时省力。这个“瞬间规划”背后的核心引擎，就是最短路径算法。

在计算机的世界里，“最短路径”问题无处不在。它远不止于导航。比如，在网络路由中，数据包要从你的手机发到千里之外的服务器，中间经过无数个路由器，怎么走延迟最低、丢包最少？这需要算最短路径。在物流配送中，一个仓库要给几十个网点送货，如何规划路线使总里程最短、油耗最低？这还是最短路径问题。甚至在一些看似不相关的领域，比如社交网络里计算两个人的“关系距离”（通过多少共同好友可以认识），或者电路板布线时寻找最短的电气连接，其底层逻辑都和图的最短路径息息相关。

所以，搞懂最短路径算法，绝不是为了应付考试或者刷题。它是你理解众多复杂系统如何高效运作的一把钥匙。今天，我们就来深入剖析两个最经典、也最实用的单源最短路径算法：Dijkstra（迪杰斯特拉）算法和Bellman-Ford（贝尔曼-福特）算法。我会用最“人话”的方式，带你弄明白它们各自是怎么想的，在什么场景下该用谁，以及实际写代码时有哪些教科书上不会告诉你的坑。

2. Dijkstra算法：稳扎稳打的“贪心”探索者

想象一下，你在一片未知的森林里，手里有一张标明了所有道路和距离的地图，但你看不到全貌，只能一步步探索。你的目标是找到从营地（起点）到宝藏（终点）的最短路径。Dijkstra算法的策略就像一个极其谨慎的探险家： 每次都从当前已知的、距离起点最近的那个路口出发，去探索它的邻居，并不断更新我们对“已知最短距离”的认识。

2.1 核心思想与“松弛”操作

Dijkstra算法基于一个非常直观的贪心思想： 如果从起点到顶点v的最短路径经过了顶点u，那么这条路径中从起点到u的那部分，也必定是从起点到u的最短路径。 换句话说，最短路径的子路径也是最短的。

基于这个思想，算法维护两个关键集合：

1. 已确定最短路径的顶点集合（S） ：这里的“确定”意味着从起点到这些顶点的最短距离已经不会再被更新了。
2. 未确定最短路径的顶点集合（Q） ：这些顶点的最短距离还是“临时”的，可能会被更新。

算法的核心操作叫做“松弛”（Relax）。假设我们已知起点s到顶点u的最短距离是 dist[u] ，现在考察一条从u到v的边，其权重为 w 。松弛操作就是检查： 如果通过u“绕道”去v，会不会比我们当前已知的去v的路径更短？ 用代码表示就是这个逻辑：

if dist[u] + w < dist[v]:
    dist[v] = dist[u] + w
    # 同时记录下v当前是从u过来的，用于最后回溯路径
    predecessor[v] = u

这个操作是Dijkstra和Bellman-Ford算法的基石，理解了它，就理解了最短路径计算的精髓。

2.2 一步步拆解：Dijkstra是如何工作的

让我们用一个具体的例子，手把手走一遍。下图是一个有向带权图，我们想求从顶点A到其他所有顶点的最短路径。

（为了说明，我们假设一个简单的图：A->B (10), A->C (3), C->B (4), C->D (2), B->D (1), D->C (7)）

初始化：

• 起点A的距离设为0： dist[A] = 0 。
• 其他所有顶点（B, C, D）的距离设为无穷大（∞），表示暂时不可达。
• 所有顶点都放入未确定集合Q中。

第一轮迭代：

• 从Q中选出距离最小的顶点，当前是A（dist=0）。将A移入已确定集合S。
• 松弛A的所有出边：
  • A->B (10): dist[A]+10=10 ，小于 dist[B] 的∞，更新 dist[B]=10 , pre[B]=A 。
  • A->C (3): dist[A]+3=3 ，小于 dist[C] 的∞，更新 dist[C]=3 , pre[C]=A 。
• 此时状态：S={A}, Q={B(10), C(3), D(∞)}。

第二轮迭代：

• 从Q中选出距离最小的顶点，是C（dist=3）。将C移入S。
• 松弛C的所有出边：
  • C->B (4): dist[C]+4=7 ，小于 dist[B] 的10，更新 dist[B]=7 , pre[B]=C 。（ 关键！ 发现了去B的更短路径A->C->B）
  • C->D (2): dist[C]+2=5 ，小于 dist[D] 的∞，更新 dist[D]=5 , pre[D]=C 。
• 此时状态：S={A, C}, Q={B(7), D(5)}。

第三轮迭代：

• 从Q中选出距离最小的顶点，是D（dist=5）。将D移入S。
• 松弛D的出边：
  • D->C (7): dist[D]+7=12 ，大于 dist[C] 的3，不更新。（C已在S中，实际上对于Dijkstra，已确定集合的顶点可以不松弛，因为其距离已是最短）
• 此时状态：S={A, C, D}, Q={B(7)}。

第四轮迭代：

• 从Q中选出最后一个顶点B（dist=7），移入S。B没有出边，无需松弛。
• 最终，所有顶点都已确定。最短路径距离为：A:0, B:7, C:3, D:5。

通过回溯 pre 数组，我们可以得到路径，例如到B的最短路径是A->C->B。

2.3 时间复杂度与堆优化

基础的Dijkstra算法需要循环V次（V为顶点数），每次都要遍历所有顶点来找出Q中距离最小的那个，所以时间复杂度是O(V²)。这在顶点很多的时候（比如上万甚至上百万）是无法接受的。

优化的关键：使用优先队列（堆）。 我们不需要每次都扫描所有顶点来找最小值。我们可以用一个最小堆来维护未确定集合Q。这样，每次从堆顶取出距离最小的顶点只需要O(log V)的时间，而每次更新一个邻接顶点的距离后，需要调整堆，也是O(log V)。对于每条边E，最多进行一次松弛和堆调整。

因此， 使用二叉堆优化的Dijkstra算法时间复杂度为O((V+E) log V) 。如果使用更高效的斐波那契堆，可以优化到O(E + V log V)，这在边数非常多的稠密图中有优势。但在绝大多数工程实践中，二叉堆（通常由编程语言的标准库提供，如C++的 priority_queue ，Python的 heapq ）的实现简单高效，是完全够用的。

这里给一个使用邻接表和最小堆的Python伪代码示例，让你感受一下优化后的核心逻辑：

import heapq

def dijkstra_heap(graph, start):
    V = len(graph)
    dist = [float('inf')] * V
    dist[start] = 0
    pq = [(0, start)]  # (距离, 顶点)
    visited = [False] * V

    while pq:
        current_dist, u = heapq.heappop(pq)
        if visited[u]:
            continue  # 如果这个顶点已经处理过（由于堆中可能有同一顶点的多个旧记录），跳过
        visited[u] = True

        for v, weight in graph[u]: # 遍历u的所有邻居
            if not visited[v]:
                new_dist = current_dist + weight
                if new_dist < dist[v]:
                    dist[v] = new_dist
                    heapq.heappush(pq, (new_dist, v))
    return dist

注意 ：这段代码有一个经典细节。当我们更新一个顶点的距离时，我们是直接把新的（更小的）距离和顶点压入堆中，而不是去修改堆中旧的值。这会导致堆中可能存在同一个顶点的多个不同距离的记录。但没关系，当我们从堆中弹出时，总是先弹出距离最小的那个记录。一旦某个顶点被标记为 visited ，后续从堆中弹出的、属于该顶点的更大距离的记录都会被 if visited[u]: continue 语句跳过。这是一种常见且有效的“惰性删除”技巧。

2.4 Dijkstra的“阿喀琉斯之踵”：负权边

Dijkstra算法很美，但它有一个致命的前提假设： 图中所有边的权重都必须为非负数（>=0） 。

为什么负权边会是问题？回顾一下Dijkstra的贪心策略：它一旦把一个顶点u加入已确定集合S，就认为从起点到u的最短距离已经找到了，不会再更新。这个结论在全是非负权重的世界里是成立的，因为如果你后面想通过其他路径再绕回u，由于所有边权非负，绕的路只会更长，不可能比已知的最短距离更短。

但是， 如果存在负权边，这个“定论”就被打破了 。因为可能存在一条路径，先绕到其他地方，再通过一条负权边“跳回”u，使得总距离反而比之前确定的 dist[u] 更小！Dijkstra算法由于不会回头去更新已确定的顶点，就会错过这个真正的更优解，从而得出错误的结果。

举个例子：假设从A到B直接走距离是5。但从A到C距离是2，C到B距离是-4。那么A->C->B的总距离是-2，比直接走的5要短。如果Dijkstra先把B（距离5）确定了，它就不会再去考虑A->C->B这条包含负权边的更短路径了。

所以，请牢记： Dijkstra算法不能处理包含负权边的图 。如果你的问题场景中可能存在负权重（比如金融网络中的套利路径，某些权重可能表示成本或收益），那么你就需要请出下一位选手：Bellman-Ford算法。

3. Bellman-Ford算法：以“耐力”取胜的全局审查官

如果说Dijkstra是一个精明但挑剔的先锋，只走“看得见”的最短路径，那么Bellman-Ford就是一个极具耐心的审查官。它不假设任何前提，而是采用一种“暴力但全面”的策略： 对图中所有的边，进行反复多次的松弛操作，直到没有任何更新可能为止。

3.1 核心思想与算法流程

Bellman-Ford算法的思想比Dijkstra更直接，也更强健：

1. 初始化起点距离为0，其他点为无穷大。
2. 进行 |V| - 1 轮松弛操作。在每一轮中，都遍历图中的 所有边 ，并对每条边尝试进行一次松弛。
3. 再进行 第 |V| 轮 检查。如果这一轮还能对任何边进行松弛，那么说明图中存在 从起点可达的负权环 。

为什么是 |V| - 1 轮？考虑最坏情况，最短路径是一条简单的、从一个顶点到另一个顶点的链，它最多包含 |V| - 1 条边。在每一轮全局松弛中，最短路径的信息至少可以沿着路径向前“传播”一个顶点。经过 |V| - 1 轮，即使是最长的简单路径，其信息也肯定能从起点传播到终点。

它的伪代码清晰反映了这个过程：

function BellmanFord(graph, start):
    dist[] = 初始化为无穷大
    dist[start] = 0

    // 松弛 |V|-1 轮
    for i from 1 to |V|-1:
        for each edge (u, v) with weight w in graph:
            if dist[u] + w < dist[v]:
                dist[v] = dist[u] + w
                predecessor[v] = u

    // 检查负权环
    for each edge (u, v) with weight w in graph:
        if dist[u] + w < dist[v]:
            return "图中存在从起点可达的负权环，无最短路径解"
    return dist, predecessor

3.2 图解Bellman-Ford：慢工出细活

我们用一个包含负权边但无负权环的图来演示。假设图有顶点A, B, C, D。边为：A->B(4), A->C(5), B->C(-2), C->D(3), D->B(-1)。起点为A。

初始化： dist[A]=0 , dist[B]=dist[C]=dist[D]=∞ 。

第一轮松弛（遍历所有边）：

• A->B(4): 0+4<∞, 更新 dist[B]=4
• A->C(5): 0+5<∞, 更新 dist[C]=5
• B->C(-2): 4+(-2)=2 < 5, 更新 dist[C]=2 （ 关键！ 发现了更短的A->B->C路径）
• C->D(3): 2+3=5 < ∞, 更新 dist[D]=5
• D->B(-1): 5+(-1)=4, 不小于当前 dist[B]=4 ，不更新。 第一轮后：dist: A0, B4, C2, D5。

第二轮松弛：

• A->B(4): 无更新。
• A->C(5): 无更新。
• B->C(-2): 4+(-2)=2, 无更新。
• C->D(3): 2+3=5, 无更新。
• D->B(-1): 5+(-1)=4, 无更新。 第二轮后无任何更新，松弛提前结束（实际实现中可以加标志位优化，如果一轮中没有任何松弛发生，就可以提前终止）。

检查负权环（第三轮检查）： 遍历所有边，都无法再进行松弛，因此判定图中无负权环。最终结果即为最短路径。

可以看到，Bellman-Ford通过两轮全局松弛，成功计算出了在包含负权边情况下的正确最短路径。它的过程虽然比Dijkstra慢，但保证了正确性。

3.3 负权环检测：算法的另一项关键能力

Bellman-Ford算法不仅能处理负权边，它的一个巨大价值在于 能够检测出图中是否存在从起点可达的负权环 。

什么是负权环？就是一个总权重为负数的环路。例如 A->B(1), B->C(1), C->A(-3)，这个环的总权重是-1。如果这样的环存在于从起点出发能到达的路径上，那么最短路径问题就“无解”了。因为你可以沿着这个环无限绕圈，每绕一圈总距离就减少一点（负权重），理论上可以达到负无穷大，根本不存在“最短”路径。

Bellman-Ford算法在完成 |V|-1 轮松弛后，特意进行第 |V| 轮检查。如果这一轮还能松弛任何边，那就说明存在一条路径，在已经过了 |V|-1 条边（即最大简单路径长度）之后，还能变得更短。这只有在存在负权环的情况下才可能发生。这个检测机制对于金融风险控制、网络协议验证等场景至关重要。

3.4 时间复杂度与稀疏图优势

Bellman-Ford算法的时间复杂度非常直观：O(V * E)。因为它要进行 V-1 轮操作，每轮遍历所有 E 条边。

乍一看，这比堆优化的Dijkstra的 O((V+E) log V) 要差。对于稠密图（E接近V²），确实如此。 但是，对于稀疏图（E与V同数量级），并且图中存在负权边时，Bellman-Ford是唯一可靠的选择。 此外，它的实现极其简单，不易出错，在顶点数不是特别多（例如几千以内）的情况下，其性能是可以接受的。

实操心得 ：在比赛或者快速原型开发中，如果图很小（V<1000），我有时甚至会直接用Bellman-Ford，因为写起来快，不容易在负权边上踩坑。当然，对于大规模正权图，一定要用Dijkstra。

4. 正面交锋：Dijkstra vs Bellman-Ford 场景化选型指南

纸上谈兵终觉浅，绝知此事要选型。理解了原理，我们最终要落实到“用谁”的问题上。下面这个表格从多个维度进行了对比，你可以像查手册一样使用它：

选型决策流：

1. 首先问：图中是否有负权边？
   • 有 -> 无脑选择 Bellman-Ford 。
   • 没有 -> 进入下一步。
2. 图规模大吗？对性能要求高吗？
   • 规模大（V, E上万）-> 选择 堆优化的Dijkstra 。
   • 规模小，或者快速实现原型 -> 两者皆可，Dijkstra通常更快。
3. 需要检测负权环吗？
   • 需要 -> 必须用 Bellman-Ford 。
   • 不需要 -> 根据1和2选择。

一个常见的误解 ：有人认为Bellman-Ford在任何情况下都比Dijkstra慢，所以能不用就不用。其实在稀疏图且存在负权边时，你根本没得选。而在小规模正权图上，两者性能差异可能并不明显，Bellman-Ford的代码简洁反而是优势。

5. 从理论到实践：编码细节与性能优化陷阱

懂了原理，看了对比，最后还得落到代码上。这里分享几个在实现这两个算法时，教科书里不一定强调，但实际编码中一定会遇到的细节和“坑”。

5.1 Dijkstra实现中的“坑”

1. 图的存储结构： 对于稀疏图， 邻接表 是唯一选择（空间O(V+E)）。对于稠密图，邻接矩阵也可以。在堆优化Dijkstra中，我们几乎总是用邻接表。可以用 vector<vector<pair<int, int>>> (C++)或 list of lists (Python)来存，每个 pair 是 (邻居顶点, 边权) 。

2. 优先队列的“重复顶点”问题： 如前所述，当我们更新一个顶点的距离时，是直接 push 新数据进堆，而不是 decrease-key 。这会导致堆里有同一顶点的多个记录。必须用 visited 数组或判断弹出的距离是否大于当前 dist 数组中的值来跳过旧记录。这是新手最容易出错的地方之一。

3. 路径还原： 算法通常只算出最短距离。如果需要路径，必须维护一个 predecessor （前驱）数组。在每次成功松弛 dist[v] 时，记录 pre[v] = u 。最后从终点倒推回起点即可。

4. 无穷大的表示： 使用一个足够大的数（如 0x3f3f3f3f ，其两倍仍在int范围内）比用浮点数 inf 有时更安全，避免溢出。在比较 dist[u] + w < dist[v] 时，如果 dist[u] 是无穷大，加法可能导致溢出，需要先判断。

5.2 Bellman-Ford实现与SPFA优化

1. 标准的Bellman-Ford实现：

def bellman_ford(edges, V, start):
    dist = [float('inf')] * V
    dist[start] = 0
    predecessor = [-1] * V

    # 松弛 V-1 轮
    for _ in range(V - 1):
        updated = False
        for u, v, w in edges: # edges是(u, v, w)的列表
            if dist[u] + w < dist[v]:
                dist[v] = dist[u] + w
                predecessor[v] = u
                updated = True
        if not updated: # 提前终止优化
            break

    # 检测负权环
    for u, v, w in edges:
        if dist[u] + w < dist[v]:
            print("存在负权环！")
            return None, None
    return dist, predecessor

注意 edges 的存储方式，这里用的是边列表，遍历起来方便。

2. SPFA (Shortest Path Faster Algorithm)： 你可以把SPFA理解为Bellman-Ford的一个“队列优化”版本。它不像Bellman-Ford那样盲目松弛所有边，而是用一个队列来维护“距离被更新过的顶点”，只从这些顶点出发去松弛邻居。它的平均时间复杂度往往比Bellman-Ford好很多，接近O(kE)，其中k是一个较小的常数。 但是，它的最坏时间复杂度仍然是O(VE) ，并且可以被特殊构造的数据卡掉。因此在算法竞赛中需谨慎使用，但在一些对平均性能要求高、且没有恶意数据的实际场景中，SPFA很受欢迎。

def spfa(graph, V, start):
    dist = [float('inf')] * V
    in_queue = [False] * V
    count = [0] * V # 记录入队次数，用于检测负环
    dist[start] = 0
    queue = deque([start])
    in_queue[start] = True
    count[start] += 1

    while queue:
        u = queue.popleft()
        in_queue[u] = False
        for v, w in graph[u]:
            if dist[u] + w < dist[v]:
                dist[v] = dist[u] + w
                if not in_queue[v]:
                    queue.append(v)
                    in_queue[v] = True
                    count[v] += 1
                    if count[v] > V: # 一个顶点入队超过V次，说明有负环
                        print("存在负权环！")
                        return None
    return dist

重要提醒 ：SPFA的负环检测（ count[v] > V ）只是一个充分条件，并非教科书式的严格检测。更严谨的负环检测需要记录路径长度（边数），当路径边数>=V时则存在环。上述简易方法在多数情况下有效，但并非百分百可靠（特别是在图不连通时）。生产环境如需严格检测，建议使用标准的Bellman-Ford。

5.3 性能优化与实战技巧

1. 针对Dijkstra的优化：

• 双向搜索 ：如果起点和终点都已知，可以同时从起点和终点运行Dijkstra，当两边的搜索区域相遇时停止。这在图非常大时能显著减少搜索范围。
• A*搜索 ：在Dijkstra的基础上，引入一个启发式函数（如地理距离）来预估到终点的代价，优先探索“方向正确”的顶点。这是地图导航算法的核心。
• 使用更快的堆 ：在C++中， std::priority_queue 是二叉堆。对于极端性能要求的场景，可以考虑手写斐波那契堆或配对堆，虽然实现复杂，但理论复杂度更优。

2. 针对Bellman-Ford/SPFA的优化：

• 提前终止 ：如上代码所示，如果一轮松弛中没有发生任何更新，说明所有最短路径已经找到，可以提前结束。
• 随机化或优化队列顺序 ：对于SPFA，使用双端队列（deque）并采用“Small Label First”策略（将新距离与队首比较，如果更小则从队首插入）有时能获得更好的平均性能。
• 差分约束系统 ：Bellman-Ford算法是求解差分约束系统（如 x_j - x_i <= c_k ）的经典方法。如果你遇到这类建模问题，直接想到Bellman-Ford就对了。

6. 融会贯通：当算法遇到真实世界问题

算法不是空中楼阁，最终要解决实际问题。让我们看几个经典应用场景，看看Dijkstra和Bellman-Ford是如何被“用活”的。

场景一：网络路由协议 像OSPF这样的链路状态路由协议，其核心就是 Dijkstra算法 。每个路由器都维护着整个网络的拓扑图（边权可以是带宽、延迟、成本等），定期运行Dijkstra来计算到达所有其他路由器的最短路径，从而构建自己的路由表。为什么用Dijkstra？因为网络链路度量（metric）总是正的（延迟、跳数等），且需要快速收敛。Bellman-Ford的思想则体现在RIP这类距离矢量协议中，通过邻居间交换信息来迭代更新，但因其收敛慢（计数到无穷问题）已逐渐被淘汰。

场景二：金融套利检测 这是一个经典的 负权环检测 问题。假设有多种货币，汇率构成一个图（顶点是货币，边权是汇率的对数）。如果存在一个环，其上的汇率乘积大于1（即边权之和大于0），就存在套利机会。但通常我们会对汇率取负对数，这样“乘积大于1”就转化为“边权之和小于0”，问题就变成了在图中寻找负权环——这正是Bellman-Ford算法的拿手好戏。金融交易系统用它来实时监控市场，发现瞬时的套利机会。

场景三：游戏地图中的寻路 在大型多人在线游戏或策略游戏中，单位寻路是高频操作。地图通常被网格化或导航网格化，边权是移动成本。 A*算法 ，本质上是带了启发函数的Dijkstra，是这里的主流选择。因为它能更快地导向目标。对于动态变化的成本（如被临时占领的区域），可能需要结合D* Lite等增量搜索算法，但其基础仍是最短路径计算。

场景四：项目管理与关键路径 在PERT图或关键路径法（CPM）中，你需要计算项目的最早完成时间。这可以建模为一个有向无环图，边权代表任务持续时间。求最长路径（对应最早完成时间）。对于有向无环图，可以通过拓扑排序后按顺序松弛边来求最长路径，其思想与Bellman-Ford一脉相承（因为无环，所以不会无限循环）。如果任务间有最小时间间隔约束，就可能出现负权边，又需要Bellman-Ford出马。

7. 不止于此：延伸思考与常见问题

学完这两个算法，你可能会有些疑问，这里集中解答一下：

Q1: 为什么Dijkstra不能处理负权边，而Bellman-Ford可以？ 这源于两者的根本策略。Dijkstra是一种“贪心”算法，它一旦认为某个点的距离已确定，就再也不回头看了。这个“确定”性依赖于边权非负的保证。Bellman-Ford则是一种“动态规划”或“迭代逼近”，它通过多次全局检查，允许对任何点的距离进行反复修正，直到无法修正为止，因此能处理更复杂的情况，包括负权边。

Q2: 如果图中有负权边，但我知道没有负权环，可以用Dijkstra吗？ 绝对不行！ 即使没有负权环，只要存在负权边，Dijkstra的贪心选择策略就可能做出错误的、不可逆的决定，导致最终结果错误。这是一个原则性问题，不是概率问题。

Q3: 所有点对之间的最短路径怎么办？ Dijkstra和Bellman-Ford解决的是“单源”最短路径。如果你需要求图中任意两点间的最短路径（所有点对），有两种主流方法：

1. 跑V次单源算法 ：对每个顶点作为起点，跑一次Dijkstra（如果图无负权）或Bellman-Ford（如果有负权）。对于稠密图，跑V次Dijkstra (O(V³ log V)) 可能不如Floyd-Warshall算法高效。
2. Floyd-Warshall算法 ：基于动态规划，时间复杂度O(V³)，空间复杂度O(V²)。它的代码极其简洁（三重循环），能处理负权边（但不能有负权环），并且直接计算出所有点对之间的距离。在顶点数不多（V<500）时非常方便。

Q4: 在实际工程中，如何存储超大规模的图？ 当顶点和边数量达到亿级别时，内存中存储邻接表都可能不够。这时需要：

• 使用外部存储 ：将图数据存储在磁盘或分布式文件系统上，按需加载。
• 图数据库 ：使用Neo4j、JanusGraph等专门的图数据库，它们为图的存储和查询（包括路径查找）做了深度优化。
• 分布式计算框架 ：使用像Pregel、GraphX（Spark）这样的图计算框架，将图分割到多台机器上并行计算。这些框架内部实现的单源最短路径算法，思想也源于我们今天讨论的算法。

Q5: 除了距离，边权还可以是什么？ 边权可以非常灵活，代表任何可以累加的“代价”。可以是时间、金钱、概率（取负对数后相加）、可靠性、甚至是自定义的复合指标。只要“最短路径”的定义符合你的业务逻辑（比如代价最小、可靠性最高），这些算法就可以应用。关键在于， 松弛操作中的“加法”和“比较”必须对你的权重类型有意义 。例如，如果求概率最大的路径，松弛操作就应该是 if prob[u] * w > prob[v] 。

理解Dijkstra和Bellman-Ford，不仅仅是学会了两个算法，更是掌握了一类问题的思考方式。它们一个代表了对“最优子结构”和“贪心选择”的利用，另一个则体现了“动态规划”和“迭代松弛”的威力。在遇到新的问题时，不妨先想想：这个问题能建模成图吗？边的权重代表什么？有没有负值？需要检测环路吗？想清楚这些，你自然就能选出最合适的武器。