文章链接：dijkstra（堆优化版）精讲、Bellman_ford 算法精讲
题目链接：47. 参加科学大会、94. 城市间货物运输 I
dijkstra（堆优化版）精讲
思路：
其实思路依然是 dijkstra 三部曲：
第一步，选源点到哪个节点近且该节点未被访问过；
第二步，该最近节点被标记访问过；
第三步，更新非访问节点到源点的距离（即更新minDist数组）。
只不过之前是 通过遍历节点来遍历边，通过两层for循环来寻找距离源点最近节点。 这次我们直接遍历边，且通过堆来对边进行排序，达到直接选择距离源点最近节点。
#include <iostream>
#include <vector>
#include <list>
#include <queue>
#include <climits>
using namespace std;
// 小顶堆
class mycomparison {
public:
bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
return lhs.second > rhs.second;
}
};
// 定义一个结构体来表示带权重的边
struct Edge {
int to; // 邻接顶点
int val; // 边的权重
Edge(int t, int w): to(t), val(w) {} // 构造函数
// Edge(int t, int w) 是一个构造函数，
// 用于创建 Edge 对象时初始化 to 和 val。
// 它接受两个参数 t 和 w，分别用于初始化 to 和 val。
};
int main() {
int n, m, p1, p2, val;
cin >> n >> m;
vector<list<Edge>> grid(n + 1);
for (int i = 0; i < m; i++) { // 记录图
cin >> p1 >> p2 >> val;
grid[p1].push_back(Edge(p2, val)); // p1 指向 p2，权值为 val
}
int start = 1;
int end = n;
vector<int> minDist(n + 1, INT_MAX); // 记录源点到每个节点的最短距离
vector<bool> visited(n + 1, false); // 记录点是否被访问过
// 优先队列中存放 pair<节点，源点到该节点的权值>
priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pq;
// 初始化队列，源点到源点的距离为0，所以初始为0
pq.push(pair<int, int>(start, 0));
minDist[start] = 0;
while (!pq.empty()) {
// 1. 第一步，选源点到哪个节点近且该节点未被访问过 （通过优先级队列来实现）
// <节点， 源点到该节点的距离>
pair<int, int> cur = pq.top(); pq.pop();
if (visited[cur.first]) continue;
// 2. 第二步，该最近节点被标记访问过
visited[cur.first] = true;
// 3. 第三步，更新非访问节点到源点的距离（即更新minDist数组）
for (Edge edge : grid[cur.first]) { // 遍历 cur指向的节点，cur指向的节点为 edge
// cur指向的节点edge.to，这条边的权值为 edge.val
if (!visited[edge.to] && minDist[cur.first] + edge.val < minDist[edge.to]) { // 更新minDist
minDist[edge.to] = minDist[cur.first] + edge.val;
pq.push(pair<int, int>(edge.to, minDist[edge.to]));
}
}
}
if (minDist[end] == INT_MAX) {
cout << -1 << '\n';
} else {
cout << minDist[end] << '\n';
}
}Bellman_ford 算法精讲
B站动画讲解：【贝尔曼福特算法说人话版(Bellman-Ford)】https://www.bilibili.com/video/BV1j34y1s7d8?vd_source=65a224d3f97ae5a1002c0964faf8a876
B站讲解：【最短路径（二）Bellman-Ford算法】https://www.bilibili.com/video/BV18a4y1A7gv?vd_source=65a224d3f97ae5a1002c0964faf8a876
本质：
也是求最短路，区别就是边的权值是有负数的。
（使用dijkstra 的话，则要求图中边的权值都为正数。）
思路：
Bellman_ford算法的核心思想是：对所有边进行松弛n-1次操作（n为节点数量），从而求得目标最短路。
什么是“松弛”：
minDist[B] = min(minDist[A] + value, minDist[B]); // 核心代码那么要松弛多少次才能计算出结果：
对所有边松弛一次，相当于计算 起点到达与起点一条边相连的节点的最短距离。
所以对所有边松弛一次 能得到 与起点 一条边相连的节点最短距离；
那对所有边松弛两次 可以得到与起点 两条边相连的节点的最短距离；
…………
对所有边松弛 n-1 次 就一定能得到 起点到达 终点的最短距离。
#include <iostream>
#include <vector>
#include <list>
#include <climits>
using namespace std;
int main() {
int n, m, p1, p2, val;
cin >> n >> m;
vector<vector<int>> grid;
// 将所有边保存起来
for(int i = 0; i < m; i++){
cin >> p1 >> p2 >> val;
// p1 指向 p2，权值为 val
grid.push_back({p1, p2, val});
}
int start = 1; // 起点
int end = n; // 终点
vector<int> minDist(n + 1 , INT_MAX);
minDist[start] = 0;
for (int i = 1; i < n; i++) { // 对所有边 松弛 n-1 次
for (vector<int> &side : grid) { // 每一次松弛，都是对所有边进行松弛
int from = side[0]; // 边的出发点
int to = side[1]; // 边的到达点
int price = side[2]; // 边的权值
// 松弛操作
// minDist[from] != INT_MAX 防止从未计算过的节点出发
if (minDist[from] != INT_MAX && minDist[to] > minDist[from] + price) {
minDist[to] = minDist[from] + price;
}
}
}
if (minDist[end] == INT_MAX) cout << "unconnected" << endl; // 不能到达终点
else cout << minDist[end] << endl; // 到达终点最短路径
}
