参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们受益！
# bellman_ford之单源有限最短路
[卡码网：96. 城市间货物运输 III](https://kamacoder.com/problempage.php?pid=1154)
【题目描述】
某国为促进城市间经济交流，决定对货物运输提供补贴。共有 n 个编号为 1 到 n 的城市，通过道路网络连接，网络中的道路仅允许从某个城市单向通行到另一个城市，不能反向通行。
网络中的道路都有各自的运输成本和政府补贴，道路的权值计算方式为：运输成本 - 政府补贴。
权值为正表示扣除了政府补贴后运输货物仍需支付的费用；
权值为负则表示政府的补贴超过了支出的运输成本，实际表现为运输过程中还能赚取一定的收益。
请计算在最多经过 k 个城市的条件下，从城市 src 到城市 dst 的最低运输成本。
【输入描述】
第一行包含两个正整数，第一个正整数 n 表示该国一共有 n 个城市，第二个整数 m 表示这些城市中共有 m 条道路。
接下来为 m 行，每行包括三个整数，s、t 和 v，表示 s 号城市运输货物到达 t 号城市，道路权值为 v。
最后一行包含三个正整数，src、dst、和 k，src 和 dst 为城市编号，从 src 到 dst 经过的城市数量限制。
【输出描述】
输出一个整数，表示从城市 src 到城市 dst 的最低运输成本，如果无法在给定经过城市数量限制下找到从 src 到 dst 的路径，则输出 "unreachable"，表示不存在符合条件的运输方案。
输入示例：
```
6 7
1 2 1
2 4 -3
2 5 2
1 3 5
3 5 1
4 6 4
5 6 -2
2 6 1
```
输出示例：
```
0
```
## 思路
本题为单源有限最短路问题，同样是 [kama94.城市间货物运输I](./0094.城市间货物运输I.md) 延伸题目。
注意题目中描述是 **最多经过 k 个城市的条件下，而不是一定经过k个城市，也可以经过的城市数量比k小，但要最短的路径**。
在 [kama94.城市间货物运输I](./0094.城市间货物运输I.md) 中我们讲了：**对所有边松弛一次，相当于计算 起点到达 与起点一条边相连的节点 的最短距离**。
节点数量为n，起点到终点，最多是 n-1 条边相连。 那么对所有边松弛 n-1 次 就一定能得到 起点到达 终点的最短距离。
（如果对以上讲解看不懂，建议详看 [kama94.城市间货物运输I](./0094.城市间货物运输I.md) ）
本题是最多经过 k 个城市， 那么是 k + 1条边相连的节点。 这里可能有录友想不懂为什么是k + 1，来看这个图：
图中，节点1 最多已经经过2个节点 到达节点4，那么中间是有多少条边呢，是 3 条边对吧。
所以本题就是求：起点最多经过k + 1 条边到达终点的最短距离。
对所有边松弛一次，相当于计算 起点到达 与起点一条边相连的节点 的最短距离，那么对所有边松弛 k + 1次，就是求 起点到达 与起点k + 1条边相连的节点的 最短距离。
**注意**： 本题是 [kama94.城市间货物运输I](./0094.城市间货物运输I.md) 的拓展题，如果对 bellman_ford 没有深入了解，强烈建议先看 [kama94.城市间货物运输I](./0094.城市间货物运输I.md) 再做本题。
理解以上内容，其实本题代码就很容易了，bellman_ford 标准写法是松弛 n-1 次，本题就松弛 k + 1次就好。
此时我们可以写出如下代码：
```CPP
// 版本一
#include
#include
#include
#include
using namespace std;
int main() {
int src, dst,k ,p1, p2, val ,m , n;
cin >> n >> m;
vector> grid;
for(int i = 0; i < m; i++){
cin >> p1 >> p2 >> val;
// p1 指向 p2，权值为 val
grid.push_back({p1, p2, val});
}
cin >> src >> dst >> k;
vector minDist(n + 1 , INT_MAX);
minDist[src] = 0;
for (int i = 1; i <= k + 1; i++) { // 对所有边松弛 k + 1次
for (vector &side : grid) {
int from = side[0];
int to = side[1];
int price = side[2];
if (minDist[from] != INT_MAX && minDist[to] > minDist[from] + price) minDist[to] = minDist[from] + price;
}
}
if (minDist[dst] == INT_MAX) cout << "unreachable" << endl; // 不能到达终点
else cout << minDist[dst] << endl; // 到达终点最短路径
}
```
以上代码 标准 bellman_ford 写法，松弛 k + 1次，看上去没什么问题。
但大家提交后，居然没通过！
这是为什么呢？
接下来我们拿这组数据来举例：
```
4 4
1 2 -1
2 3 1
3 1 -1
3 4 1
1 4 3
```
（**注意上面的示例是有负权回路的，只有带负权回路的图才能说明问题**）
> 负权回路是指一条道路的总权值为负，这样的回路使得通过反复经过回路中的道路，理论上可以无限地减少总成本或无限地增加总收益。
正常来说，这组数据输出应该是 1，但以上代码输出的是 -2。
在讲解原因的时候，强烈建议大家，先把 minDist数组打印出来，看看minDist数组是不是按照自己的想法变化的，这样更容易理解我接下来的讲解内容。 （**一定要动手，实践出真实，脑洞模拟不靠谱**）
打印的代码可以是这样：
```CPP
#include
#include
#include
#include
using namespace std;
int main() {
int src, dst,k ,p1, p2, val ,m , n;
cin >> n >> m;
vector> grid;
for(int i = 0; i < m; i++){
cin >> p1 >> p2 >> val;
// p1 指向 p2，权值为 val
grid.push_back({p1, p2, val});
}
cin >> src >> dst >> k;
vector minDist(n + 1 , INT_MAX);
minDist[src] = 0;
for (int i = 1; i <= k + 1; i++) { // 对所有边松弛 k + 1次
for (vector &side : grid) {
int from = side[0];
int to = side[1];
int price = side[2];
if (minDist[from] != INT_MAX && minDist[to] > minDist[from] + price) minDist[to] = minDist[from] + price;
}
// 打印 minDist 数组
for (int j = 1; j <= n; j++) cout << minDist[j] << " ";
cout << endl;
}
if (minDist[dst] == INT_MAX) cout << "unreachable" << endl; // 不能到达终点
else cout << minDist[dst] << endl; // 到达终点最短路径
}
```
接下来，我按照上面的示例带大家 画图举例 对所有边松弛一次 的效果图。
起点为节点1， 起点到起点的距离为0，所以 minDist[1] 初始化为0 ，如图：
其他节点对应的minDist初始化为max，因为我们要求最小距离，那么还没有计算过的节点 默认是一个最大数，这样才能更新最小距离。
当我们开始对所有边开始第一次松弛：
边：节点1 -> 节点2，权值为-1 ，minDist[2] > minDist[1] + (-1)，更新 minDist[2] = minDist[1] + (-1) = 0 - 1 = -1 ，如图：
边：节点2 -> 节点3，权值为1 ，minDist[3] > minDist[2] + 1 ，更新 minDist[3] = minDist[2] + 1 = -1 + 1 = 0 ，如图：
边：节点3 -> 节点1，权值为-1 ，minDist[1] > minDist[3] + (-1)，更新 minDist[1] = 0 + (-1) = -1 ，如图：
边：节点3 -> 节点4，权值为1 ，minDist[4] > minDist[3] + 1，更新 minDist[4] = 0 + 1 = 1 ，如图：
以上是对所有边进行的第一次松弛，最后 minDist数组为 ：-1 -1 0 1 ，（从下标1算起）
后面几次松弛我就不挨个画图了，过程大同小异，我直接给出minDist数组的变化：
所有边进行的第二次松弛，minDist数组为 ： -2 -2 -1 0
所有边进行的第三次松弛，minDist数组为 ： -3 -3 -2 -1
所有边进行的第四次松弛，minDist数组为 ： -4 -4 -3 -2 （本示例中k为3，所以松弛4次）
最后计算的结果minDist[4] = -2，即 起点到 节点4，最多经过 3 个节点的最短距离是 -2，但 正确的结果应该是 1，即路径：节点1 -> 节点2 -> 节点3 -> 节点4。
理论上来说，**对所有边松弛一次，相当于计算 起点到达 与起点一条边相连的节点 的最短距离**。
对所有边松弛两次，相当于计算 起点到达 与起点两条边相连的节点的最短距离。
对所有边松弛三次，以此类推。
但在对所有边松弛第一次的过程中，大家会发现，不仅仅 与起点一条边相连的节点更新了，所有节点都更新了。
而且对所有边的后面几次松弛，同样是更新了所有的节点，说明 至多经过k 个节点 这个限制 根本没有限制住，每个节点的数值都被更新了。
这是为什么？
在上面画图距离中，对所有边进行第一次松弛，在计算 边（节点2 -> 节点3） 的时候，更新了 节点3。
理论上来说节点3 应该在对所有边第二次松弛的时候才更新。 这因为当时是基于已经计算好的 节点2（minDist[2]）来做计算了。
minDist[2]在计算边：（节点1 -> 节点2）的时候刚刚被赋值为 -1。
这样就造成了一个情况，即：计算minDist数组的时候，基于了本次松弛的 minDist数值，而不是上一次 松弛时候minDist的数值。
所以在每次计算 minDist 时候，要基于 对所有边上一次松弛的 minDist 数值才行，所以我们要记录上一次松弛的minDist。
代码修改如下： （关键地方已经注释）
```CPP
// 版本二
#include
#include
#include
#include
using namespace std;
int main() {
int src, dst,k ,p1, p2, val ,m , n;
cin >> n >> m;
vector> grid;
for(int i = 0; i < m; i++){
cin >> p1 >> p2 >> val;
grid.push_back({p1, p2, val});
}
cin >> src >> dst >> k;
vector minDist(n + 1 , INT_MAX);
minDist[src] = 0;
vector minDist_copy(n + 1); // 用来记录上一次遍历的结果
for (int i = 1; i <= k + 1; i++) {
minDist_copy = minDist; // 获取上一次计算的结果
for (vector &side : grid) {
int from = side[0];
int to = side[1];
int price = side[2];
// 注意使用 minDist_copy 来计算 minDist
if (minDist_copy[from] != INT_MAX && minDist[to] > minDist_copy[from] + price) {
minDist[to] = minDist_copy[from] + price;
}
}
}
if (minDist[dst] == INT_MAX) cout << "unreachable" << endl; // 不能到达终点
else cout << minDist[dst] << endl; // 到达终点最短路径
}
```
* 时间复杂度： O(K * E) , K为至多经过K个节点，E为图中边的数量
* 空间复杂度： O(N) ，即 minDist 数组所开辟的空间
## 拓展一（边的顺序的影响）
其实边的顺序会影响我们每一次拓展的结果。
我来给大家举个例子。
我上面讲解中，给出的示例是这样的：
```
4 4
1 2 -1
2 3 1
3 1 -1
3 4 1
1 4 3
```
我将示例中边的顺序改一下，给成：
```
4 4
3 1 -1
3 4 1
2 3 1
1 2 -1
1 4 3
```
所构成是图是一样的，都是如下的这个图，但给出的边的顺序是不一样的。
再用版本一的代码是运行一下，发现结果输出是 1， 是对的。
分明刚刚输出的结果是 -2，是错误的，怎么 一样的图，这次输出的结果就对了呢？
其实这是和示例中给出的边的顺序是有关的，
我们按照修改后的示例再来模拟 对所有边的第一次拓展情况。
初始化：
边：节点3 -> 节点1，权值为-1 ，节点3还没有被计算过，节点1 不更新。
边：节点3 -> 节点4，权值为1 ，节点3还没有被计算过，节点4 不更新。
边：节点2 -> 节点3，权值为 1 ，节点2还没有被计算过，节点3 不更新。
边：节点1 -> 节点2，权值为 -1 ，minDist[2] > minDist[1] + (-1)，更新 minDist[2] = 0 + (-1) = -1 ，如图：
以上是对所有边 松弛一次的状态。
可以发现 同样的图，边的顺序不一样，使用版本一的代码 每次松弛更新的节点也是不一样的。
而边的顺序是随机的，是题目给我们的，所以本题我们才需要 记录上一次松弛的minDist，来保障 每一次对所有边松弛的结果。
## 拓展二（本题本质）
那么前面讲解过的 [94.城市间货物运输I](./0094.城市间货物运输I.md) 和 [95.城市间货物运输II](./0095.城市间货物运输II.md) 也是bellman_ford经典算法，也没使用 minDist_copy，怎么就没问题呢？
> 如果没看过我上面这两篇讲解的话，建议详细学习上面两篇，再看我下面讲的区别，否则容易看不懂。
[94.城市间货物运输I](./0094.城市间货物运输I.md)， 是没有 负权回路的，那么 多松弛多少次，对结果都没有影响。
求 节点1 到 节点n 的最短路径，松弛n-1 次就够了，松弛 大于 n-1次，结果也不会变。
那么在对所有边进行第一次松弛的时候，如果基于 本次计算的 minDist 来计算 minDist （相当于多做松弛了），也是对最终结果没影响。
[95.城市间货物运输II](./0095.城市间货物运输II.md) 是判断是否有 负权回路，一旦有负权回路， 对所有边松弛 n-1 次以后，在做松弛 minDist 数值一定会变，根据这一点来判断是否有负权回路。
所以，[95.城市间货物运输II](./0095.城市间货物运输II.md) 只需要判断minDist数值变化了就行，而 minDist 的数值对不对，并不是我们关心的。
那么本题 为什么计算minDist 一定要基于上次 的 minDist 数值。
其关键在于本题的两个因素：
* 本题可以有负权回路，说明只要多做松弛，结果是会变的。
* 本题要求最多经过k个节点，对松弛次数是有限制的。
## 拓展三（SPFA）
本题也可以用 SPFA来做，关于 SPFA ，已经在这里 [0094.城市间货物运输I-SPFA](./0094.城市间货物运输I-SPFA.md) 有详细讲解。
使用SPFA算法解决本题的时候，关键在于 如何控制松弛k次。
其实实现不难，但有点技巧，可以用一个变量 que_size 记录每一轮松弛入队列的所有节点数量。
下一轮松弛的时候，就把队列里 que_size 个节点都弹出来，就是上一轮松弛入队列的节点。
代码如下（详细注释）
```CPP
#include
#include
#include
#include
#include
using namespace std;
struct Edge { //邻接表
int to; // 链接的节点
int val; // 边的权重
Edge(int t, int w): to(t), val(w) {} // 构造函数
};
int main() {
int n, m, p1, p2, val;
cin >> n >> m;
vector> grid(n + 1); // 邻接表
// 将所有边保存起来
for(int i = 0; i < m; i++){
cin >> p1 >> p2 >> val;
// p1 指向 p2，权值为 val
grid[p1].push_back(Edge(p2, val));
}
int start, end, k;
cin >> start >> end >> k;
k++;
vector minDist(n + 1 , INT_MAX);
vector minDist_copy(n + 1); // 用来记录每一次遍历的结果
minDist[start] = 0;
queue que;
que.push(start); // 队列里放入起点
int que_size;
while (k-- && !que.empty()) {
minDist_copy = minDist; // 获取上一次计算的结果
que_size = que.size(); // 记录上次入队列的节点个数
while (que_size--) { // 上一轮松弛入队列的节点，这次对应的边都要做松弛
int node = que.front(); que.pop();
for (Edge edge : grid[node]) {
int from = node;
int to = edge.to;
int price = edge.val;
if (minDist[to] > minDist_copy[from] + price) {
minDist[to] = minDist_copy[from] + price;
que.push(to);
}
}
}
}
if (minDist[end] == INT_MAX) cout << "unreachable" << endl;
else cout << minDist[end] << endl;
}
```
时间复杂度： O(K * H) H 为不确定数，取决于 图的稠密度，但H 一定是小于等于 E 的
关于 SPFA的是时间复杂度分析，我在[0094.城市间货物运输I-SPFA](./0094.城市间货物运输I-SPFA.md) 有详细讲解
但大家会发现，以上代码大家提交后，怎么耗时这么多？
理论上，SPFA的时间复杂度不是要比 bellman_ford 更优吗？
怎么耗时多了这么多呢？
以上代码有一个可以改进的点，每一轮松弛中，重复节点可以不用入队列。
因为重复节点入队列，下次从队列里取节点的时候，该节点要取很多次，而且都是重复计算。
所以代码可以优化成这样：
```CPP
#include
#include
#include
#include
#include
using namespace std;
struct Edge { //邻接表
int to; // 链接的节点
int val; // 边的权重
Edge(int t, int w): to(t), val(w) {} // 构造函数
};
int main() {
int n, m, p1, p2, val;
cin >> n >> m;
vector> grid(n + 1); // 邻接表
// 将所有边保存起来
for(int i = 0; i < m; i++){
cin >> p1 >> p2 >> val;
// p1 指向 p2，权值为 val
grid[p1].push_back(Edge(p2, val));
}
int start, end, k;
cin >> start >> end >> k;
k++;
vector minDist(n + 1 , INT_MAX);
vector minDist_copy(n + 1); // 用来记录每一次遍历的结果
minDist[start] = 0;
queue que;
que.push(start); // 队列里放入起点
int que_size;
while (k-- && !que.empty()) {
vector visited(n + 1, false); // 每一轮松弛中，控制节点不用重复入队列
minDist_copy = minDist;
que_size = que.size();
while (que_size--) {
int node = que.front(); que.pop();
for (Edge edge : grid[node]) {
int from = node;
int to = edge.to;
int price = edge.val;
if (minDist[to] > minDist_copy[from] + price) {
minDist[to] = minDist_copy[from] + price;
if(visited[to]) continue; // 不用重复放入队列，但需要重复松弛，所以放在这里位置
visited[to] = true;
que.push(to);
}
}
}
}
if (minDist[end] == INT_MAX) cout << "unreachable" << endl;
else cout << minDist[end] << endl;
}
```
以上代码提交后，耗时情况：
大家发现 依然远比 bellman_ford 的代码版本 耗时高。
这又是为什么呢？
对于后台数据，我特别制作的一个稠密大图，该图有250个节点和10000条边， 在这种情况下， SPFA 的时间复杂度 是接近与 bellman_ford的。
但因为 SPFA 节点的进出队列操作，耗时很大，所以相同的时间复杂度的情况下，SPFA 实际上更耗时了。
这一点我在 [0094.城市间货物运输I-SPFA](./0094.城市间货物运输I-SPFA.md) 有分析，感兴趣的录友再回头去看看。
## 拓展四（能否用dijkstra）
本题能否使用 dijkstra 算法呢？
dijkstra 是贪心的思路 每一次搜索都只会找距离源点最近的非访问过的节点。
如果限制最多访问k个节点，那么 dijkstra 未必能在有限次就能到达终点，即使在经过k个节点确实可以到达终点的情况下。
这么说大家会感觉有点抽象，我用 [dijkstra朴素版精讲](./0047.参会dijkstra朴素.md) 里的示例在举例说明： （如果没看过我讲的[dijkstra朴素版精讲](./0047.参会dijkstra朴素.md)，建议去仔细看一下，否则下面讲解容易看不懂）
在以下这个图中，求节点1 到 节点7 最多经过2个节点 的最短路是多少呢？
最短路显然是：
最多经过2个节点，也就是3条边相连的路线：节点1 -> 节点2 -> 节点6-> 节点7
如果是 dijkstra 求解的话，求解过程是这样的： （下面是dijkstra的模拟过程，我精简了很多，如果看不懂，一定要先看[dijkstra朴素版精讲](./0047.参会dijkstra朴素.md)）
初始化如图所示：
找距离源点最近且没有被访问过的节点，先找节点1
距离源点最近且没有被访问过的节点，找节点2：
距离源点最近且没有被访问过的节点，找到节点3：
距离源点最近且没有被访问过的节点，找到节点4：
此时最多经过2个节点的搜索就完毕了，但结果中minDist[7] （即节点7的结果）并没有被更。
那么 dijkstra 会告诉我们 节点1 到 节点7 最多经过2个节点的情况下是不可到达的。
通过以上模拟过程，大家应该能感受到 dijkstra 贪心的过程，正是因为 贪心，所以 dijkstra 找不到 节点1 -> 节点2 -> 节点6-> 节点7 这条路径。
## 总结
本题是单源有限最短路问题，也是 bellman_ford的一个拓展问题，如果理解bellman_ford 其实思路比较容易理解，但有很多细节。
例如 为什么要用 minDist_copy 来记录上一轮 松弛的结果。 这也是本篇我为什么花了这么大篇幅讲解的关键所在。
接下来，还给大家做了四个拓展：
* 边的顺序的影响
* 本题的本质
* SPFA的解法
* 能否用dijkstra
学透了以上四个拓展，相信大家会对bellman_ford有更深入的理解。
## 其他语言版本
### Java
```Java
import java.util.*;
public class Main {
// 基于Bellman_for一般解法解决单源最短路径问题
// Define an inner class Edge
static class Edge {
int from;
int to;
int val;
public Edge(int from, int to, int val) {
this.from = from;
this.to = to;
this.val = val;
}
}
public static void main(String[] args) {
// Input processing
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
List graph = new ArrayList<>();
for (int i = 0; i < m; i++) {
int from = sc.nextInt();
int to = sc.nextInt();
int val = sc.nextInt();
graph.add(new Edge(from, to, val));
}
int src = sc.nextInt();
int dst = sc.nextInt();
int k = sc.nextInt();
int[] minDist = new int[n + 1];
int[] minDistCopy;
Arrays.fill(minDist, Integer.MAX_VALUE);
minDist[src] = 0;
for (int i = 0; i < k + 1; i++) { // Relax all edges k + 1 times
minDistCopy = Arrays.copyOf(minDist, n + 1);
for (Edge edge : graph) {
int from = edge.from;
int to = edge.to;
int val = edge.val;
// Use minDistCopy to calculate minDist
if (minDistCopy[from] != Integer.MAX_VALUE && minDist[to] > minDistCopy[from] + val) {
minDist[to] = minDistCopy[from] + val;
}
}
}
// Output printing
if (minDist[dst] == Integer.MAX_VALUE) {
System.out.println("unreachable");
} else {
System.out.println(minDist[dst]);
}
}
}
```
```java
class Edge {
public int u; // 边的端点1
public int v; // 边的端点2
public int val; // 边的权值
public Edge() {
}
public Edge(int u, int v) {
this.u = u;
this.v = v;
this.val = 0;
}
public Edge(int u, int v, int val) {
this.u = u;
this.v = v;
this.val = val;
}
}
/**
* SPFA算法（版本3）：处理含【负权回路】的有向图的最短路径问题
* bellman_ford（版本3） 的队列优化算法版本
* 限定起点、终点、至多途径k个节点
*/
public class SPFAForSSSP {
/**
* SPFA算法
*
* @param n 节点个数[1,n]
* @param graph 邻接表
* @param startIdx 开始节点（源点）
*/
public static int[] spfa(int n, List> graph, int startIdx, int k) {
// 定义最大范围
int maxVal = Integer.MAX_VALUE;
// minDist[i] 源点到节点i的最短距离
int[] minDist = new int[n + 1]; // 有效节点编号范围：[1,n]
Arrays.fill(minDist, maxVal); // 初始化为maxVal
minDist[startIdx] = 0; // 设置源点到源点的最短路径为0
// 定义queue记录每一次松弛更新的节点
Queue queue = new LinkedList<>();
queue.offer(startIdx); // 初始化：源点开始（queue和minDist的更新是同步的）
// SPFA算法核心：只对上一次松弛的时候更新过的节点关联的边进行松弛操作
while (k + 1 > 0 && !queue.isEmpty()) { // 限定松弛 k+1 次
int curSize = queue.size(); // 记录当前队列节点个数（上一次松弛更新的节点个数，用作分层统计）
while (curSize-- > 0) { //分层控制，限定本次松弛只针对上一次松弛更新的节点，不对新增的节点做处理
// 记录当前minDist状态，作为本次松弛的基础
int[] minDist_copy = Arrays.copyOfRange(minDist, 0, minDist.length);
// 取出节点
int cur = queue.poll();
// 获取cur节点关联的边，进行松弛操作
List relateEdges = graph.get(cur);
for (Edge edge : relateEdges) {
int u = edge.u; // 与`cur`对照
int v = edge.v;
int weight = edge.val;
if (minDist_copy[u] + weight < minDist[v]) {
minDist[v] = minDist_copy[u] + weight; // 更新
// 队列同步更新（此处有一个针对队列的优化:就是如果已经存在于队列的元素不需要重复添加）
if (!queue.contains(v)) {
queue.offer(v); // 与minDist[i]同步更新，将本次更新的节点加入队列，用做下一个松弛的参考基础
}
}
}
}
// 当次松弛结束，次数-1
k--;
}
// 返回minDist
return minDist;
}
public static void main(String[] args) {
// 输入控制
Scanner sc = new Scanner(System.in);
System.out.println("1.输入N个节点、M条边（u v weight）");
int n = sc.nextInt();
int m = sc.nextInt();
System.out.println("2.输入M条边");
List> graph = new ArrayList<>(); // 构建邻接表
for (int i = 0; i <= n; i++) {
graph.add(new ArrayList<>());
}
while (m-- > 0) {
int u = sc.nextInt();
int v = sc.nextInt();
int weight = sc.nextInt();
graph.get(u).add(new Edge(u, v, weight));
}
System.out.println("3.输入src dst k（起点、终点、至多途径k个点）");
int src = sc.nextInt();
int dst = sc.nextInt();
int k = sc.nextInt();
// 调用算法
int[] minDist = SPFAForSSSP.spfa(n, graph, src, k);
// 校验起点->终点
if (minDist[dst] == Integer.MAX_VALUE) {
System.out.println("unreachable");
} else {
System.out.println("最短路径：" + minDist[n]);
}
}
}
```
### Python
Bellman-Ford方法求解单源有限最短路
```python
def main():
# 輸入
n, m = map(int, input().split())
edges = list()
for _ in range(m):
edges.append(list(map(int, input().split() )))
start, end, k = map(int, input().split())
min_dist = [float('inf') for _ in range(n + 1)]
min_dist[start] = 0
# 只能經過k個城市，所以從起始點到中間有(k + 1)個邊連接
# 需要鬆弛(k + 1)次
for _ in range(k + 1):
update = False
min_dist_copy = min_dist.copy()
for src, desc, w in edges:
if (min_dist_copy[src] != float('inf') and
min_dist_copy[src] + w < min_dist[desc]):
min_dist[desc] = min_dist_copy[src] + w
update = True
if not update:
break
# 輸出
if min_dist[end] == float('inf'):
print('unreachable')
else:
print(min_dist[end])
if __name__ == "__main__":
main()
```
SPFA方法求解单源有限最短路
```python
from collections import deque
from math import inf
def main():
n, m = [int(i) for i in input().split()]
graph = [[] for _ in range(n+1)]
for _ in range(m):
v1, v2, val = [int(i) for i in input().split()]
graph[v1].append([v2, val])
src, dst, k = [int(i) for i in input().split()]
min_dist = [inf for _ in range(n+1)]
min_dist[src] = 0 # 初始化起点的距离
que = deque([src])
while k != -1 and que:
visited = [False for _ in range(n+1)] # 用于保证每次松弛时一个节点最多加入队列一次
que_size = len(que)
temp_dist = min_dist.copy() # 用于记录上一次遍历的结果
for _ in range(que_size):
cur_node = que.popleft()
for next_node, val in graph[cur_node]:
if min_dist[next_node] > temp_dist[cur_node] + val:
min_dist[next_node] = temp_dist[cur_node] + val
if not visited[next_node]:
que.append(next_node)
visited[next_node] = True
k -= 1
if min_dist[dst] == inf:
print("unreachable")
else:
print(min_dist[dst])
if __name__ == "__main__":
main()
```
### Go
### Rust
### JavaScript
### TypeScript
### PhP
### Swift
### Scala
### C#
### Dart
### C