Bellman_ford 算法--带负权值的单源最短路问题，边列表存储

目录

题目描述

 解题思路-Bellman_ford 算法

什么叫做松弛？

 为什么是 n - 1次 松弛呢？【模拟Bellman_ford】

①初始化：        

  ②对所有边 进行第一次松弛：

 存储结构？

完整代码

---

上期内容：------- 

算法-图-dijkstra 最短路径-CSDN博客

题目描述

   

 解题思路-Bellman_ford 算法

在求单源最短路的方法中，使用dijkstra 的话，则要求图中边的权值都为正数。

Bellman_ford算法的核心思想是 对所有边进行松弛n-1次操作（n为节点数量），从而求得目标最短路。 

什么叫做松弛？

例如一条边，节点A 到 节点B 权值为value，如图：

minDist[B] 表示 到达B节点 最小权值，minDist[B] 有哪些状态可以推出来？

①状态一：minDist[A] + value 可以推出 minDist[B]

②状态二：minDist[B]本身就有权值 （可能是其他边链接的节点B 例如节点C，以至于 minDist[B]记录了其他边到minDist[B]的权值）

所以：

if (minDist[B] > minDist[A] + value) minDist[B] = minDist[A] + value

如果 通过 A 到 B 这条边可以获得更短的到达B节点的路径，即如果 minDist[B] > minDist[A] + value，那么我们就更新 minDist[B] = minDist[A] + value ，这个过程就叫做 “松弛” 。 

if (minDist[B] > minDist[A] + value) minDist[B] = minDist[A] + value

这句代码就是 Bellman_ford算法的核心操作。

以上代码也可以这么写：minDist[B] = min(minDist[A] + value, minDist[B])

 为什么是 n - 1次 松弛呢？【模拟Bellman_ford】

        这里要给大家模拟一遍 Bellman_ford 的算法才行，接下来我们来看看对所有边松弛 n - 1 次的操作是什么样的。我们依然使用minDist数组来表达 起点到各个节点的最短距离

①初始化：        

起点为节点1， 起点到起点的距离为0，所以 minDist[1] 初始化为0，其他节点对应的minDist初始化为max，因为我们要求最小距离，那么还没有计算过的节点 默认是一个最大数，这样才能更新最小距离。

  ②对所有边 进行第一次松弛：

以示例给出的所有边为例：

5 6 -2
1 2 1
5 3 1
2 5 2
2 4 -3
4 6 4
1 3 5

松弛一遍所有的边：

边：节点5 -> 节点6，权值为-2 ，minDist[5] 还是默认数值max，所以不能基于 节点5 去更新节点6，如图：

边：节点1 -> 节点2，权值为1 ，minDist[2] > minDist[1] + 1 ，更新 minDist[2] = minDist[1] + 1 = 0 + 1 = 1 ，如图：

 

边：节点5 -> 节点3，权值为1 ，minDist[5] 还是默认数值max，所以不能基于节点5去更新节点3 如图：

 边：节点2 -> 节点5，权值为2 ，minDist[5] > minDist[2] + 2 （经过上面的计算minDist[2]已经不是默认值，而是 1），更新 minDist[5] = minDist[2] + 2 = 1 + 2 = 3 ，如图：

 边：节点2 -> 节点4，权值为-3 ，minDist[4] > minDist[2] + (-3)，更新 minDist[4] = minDist[2] + (-3) = 1 + (-3) = -2 ，如图：

边：节点4 -> 节点6，权值为4 ，minDist[6] > minDist[4] + 4，更新 minDist[6] = minDist[4] + 4 = -2 + 4 = 2

边：节点1 -> 节点3，权值为5 ，minDist[3] > minDist[1] + 5，更新 minDist[3] = minDist[1] + 5 = 0 + 5 = 5 ，如图： 

        以上是对所有边进行一次松弛之后的结果。对所有边松弛一次，相当于计算 起点到达 与起点一条边相连的节点 的最短距离。上面的距离中，我们得到里 起点达到 与起点一条边相邻的节点2 和 节点3 的最短距离，分别是 minDist[2] 和 minDist[3]

       “这里有录友疑惑了 minDist[3] = 5，分明不是 起点到达 节点3 的最短距离，节点1 -> 节点2 -> 节点5 -> 节点3 这条路线 距离才是4。

注意我上面讲的是 对所有边松弛一次，相当于计算 起点到达 与起点一条边相连的节点 的最短距离，这里 说的是 一条边相连的节点。

与起点（节点1）一条边相邻的节点，到达节点2 最短距离是 1，到达节点3 最短距离是5。

而 节点1 -> 节点2 -> 节点5 -> 节点3 这条路线 是 与起点 三条边相连的路线了。

”

那么需要对所有边松弛几次才能得到 起点（节点1） 到终点（节点6）的最短距离呢？对所有边松弛一次，相当于计算 起点到达 与起点一条边相连的节点 的最短距离。

 共有两个关键点。

• “松弛”究竟是个啥？
• 为什么要对所有边松弛 n - 1 次 （n为节点个数） ？

那么Bellman_ford的解题解题过程其实就是对所有边松弛 n-1 次，然后得出得到终点的最短路径。

 存储结构？

采用 边列表（edge list） 进行存储，直接存储 所有边的列表，每条边通常包含 起点、终点、权值

vector<vector<int>> edges;
edges.push_back({u, v, weight});  // 添加一条边 (u -> v, 权重 weight)

 

完整代码

#include<bits/stdc++.h>
using namespace std;

int main() {
    int n, m;
    cin >> n >> m;
    vector<vector<int>> edges; // 存储边的列表，每个边包含[起点, 终点, 权值]
    for (int i = 0; i < m; i++) {
        int p1, p2, val;
        cin >> p1 >> p2 >> val;
        edges.push_back({p1, p2, val}); // 将边添加到列表
    }
    int start = 1; // 起点
    int end = n;   // 终点
    vector<int> minDist(n + 1, INT_MAX); // 初始化最短距离数组
    minDist[start] = 0;

    // Bellman-Ford算法核心：松弛所有边n-1次
    for (int i = 1; i <= n - 1; i++) {
        for (auto &edge : edges) {
            int from = edge[0];
            int to = edge[1];
            int cost = edge[2];
            // 如果当前节点可达且松弛有效，则更新距离
            if (minDist[from] != INT_MAX) {
                minDist[to] =min(minDist[to], minDist[from] + cost);
            }
        }
    }

    // 输出结果
    if (minDist[end] == INT_MAX) {
        cout << "unconnected" << endl;
    } else {
        cout << minDist[end] << endl;
    }
    return 0;
}