代码随想录算法训练营第六十天 | Bellman_ford之单源有限最短路

最新推荐文章于 2024-10-16 00:00:43 发布

懒羊羊->加油吖

最新推荐文章于 2024-10-16 00:00:43 发布

阅读量1k

点赞数 15

分类专栏：代码随想录刷题文章标签：算法数据结构 python Bellman_ford

本文链接：https://blog.csdn.net/m0_61698277/article/details/142309799

版权

代码随想录刷题专栏收录该内容

62 篇文章 1 订阅

订阅专栏

Bellman_ford之单源有限最短路

题目链接：卡码网：96. 城市间货物运输 III

文章讲解：代码随想录

某国为促进城市间经济交流，决定对货物运输提供补贴。共有 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 延伸题目。

注意题目中描述是 最多经过 k 个城市的条件下，而不是一定经过k个城市，也可以经过的城市数量比k小，但要最短的路径。

在 kama94.城市间货物运输I 中我们讲了：对所有边松弛一次，相当于计算起点到达与起点一条边相连的节点的最短距离。

节点数量为n，起点到终点，最多是 n-1 条边相连。那么对所有边松弛 n-1 次就一定能得到起点到达终点的最短距离。

（如果对以上讲解看不懂，建议详看 kama94.城市间货物运输I ）

本题是最多经过 k 个城市，那么是 k + 1条边相连的节点。这里可能有录友想不懂为什么是k + 1，来看这个图：

图中，节点1 最多已经经过2个节点到达节点4，那么中间是有多少条边呢，是 3 条边对吧。

所以本题就是求：起点最多经过k + 1 条边到达终点的最短距离。

对所有边松弛一次，相当于计算起点到达与起点一条边相连的节点的最短距离，那么对所有边松弛 k + 1次，就是求起点到达与起点k + 1条边相连的节点的最短距离。

注意：本题是 kama94.城市间货物运输I 的拓展题，如果对 bellman_ford 没有深入了解，强烈建议先看 kama94.城市间货物运输I 再做本题。

理解以上内容，其实本题代码就很容易了，bellman_ford 标准写法是松弛 n-1 次，本题就松弛 k + 1次就好。

标准 bellman_ford 写法，松弛 k + 1次，看上去没什么问题。

但大家提交后，居然没通过！

这是为什么呢？

接下来我们拿这组数据来举例：

（注意上面的示例是有负权回路的，只有带负权回路的图才能说明问题）

负权回路是指一条道路的总权值为负，这样的回路使得通过反复经过回路中的道路，理论上可以无限地减少总成本或无限地增加总收益。

正常来说，这组数据输出应该是 1，但以上代码输出的是 -2。

接下来，我按照上面的示例带大家画图举例对所有边松弛一次的效果图。

起点为节点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。

拓展一（边的顺序的影响）

其实边的顺序会影响我们每一次拓展的结果。

我来给大家举个例子。

我上面讲解中，给出的示例是这样的：

我将示例中边的顺序改一下，给成：

所构成是图是一样的，都是如下的这个图，但给出的边的顺序是不一样的。

再用版本一的代码是运行一下，发现结果输出是 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 和 95.城市间货物运输II 也是bellman_ford经典算法，也没使用 minDist_copy，怎么就没问题呢？

如果没看过我上面这两篇讲解的话，建议详细学习上面两篇，再看我下面讲的区别，否则容易看不懂。

94.城市间货物运输I，是没有负权回路的，那么多松弛多少次，对结果都没有影响。

求节点1 到节点n 的最短路径，松弛n-1 次就够了，松弛大于 n-1次，结果也不会变。

那么在对所有边进行第一次松弛的时候，如果基于本次计算的 minDist 来计算 minDist （相当于多做松弛了），也是对最终结果没影响。

95.城市间货物运输II 是判断是否有负权回路，一旦有负权回路，对所有边松弛 n-1 次以后，在做松弛 minDist 数值一定会变，根据这一点来判断是否有负权回路。

所以，95.城市间货物运输II 只需要判断minDist数值变化了就行，而 minDist 的数值对不对，并不是我们关心的。

那么本题为什么计算minDist 一定要基于上次的 minDist 数值。

其关键在于本题的两个因素：

本题可以有负权回路，说明只要多做松弛，结果是会变的。
本题要求最多经过k个节点，对松弛次数是有限制的。

如果本题中没有负权回路的测试用例，那版本一的代码就可以过了，也就不用我费这么大口舌去讲解的这个坑了。

拓展三（SPFA）

本题也可以用 SPFA来做，关于 SPFA ，已经在这里 0094.城市间货物运输I-SPFA 有详细讲解。

使用SPFA算法解决本题的时候，关键在于如何控制松弛k次。

其实实现不难，但有点技巧，可以用一个变量 que_size 记录每一轮松弛入队列的所有节点数量。

下一轮松弛的时候，就把队列里 que_size 个节点都弹出来，就是上一轮松弛入队列的节点。

时间复杂度： O(K * H) H 为不确定数，取决于图的稠密度，但H 一定是小于等于 E 的

关于 SPFA的是时间复杂度分析，我在0094.城市间货物运输I-SPFA 有详细讲解

但大家会发现，以上代码大家提交后，怎么耗时这么多？

理论上，SPFA的时间复杂度不是要比 bellman_ford 更优吗？

怎么耗时多了这么多呢？

以上代码有一个可以改进的点，每一轮松弛中，重复节点可以不用入队列。

因为重复节点入队列，下次从队列里取节点的时候，该节点要取很多次，而且都是重复计算。

以上代码提交后，耗时情况：

大家发现依然远比 bellman_ford 的代码版本耗时高。

这又是为什么呢？

对于后台数据，我特别制作的一个稠密大图，该图有250个节点和10000条边，在这种情况下， SPFA 的时间复杂度是接近与 bellman_ford的。

但因为 SPFA 节点的进出队列操作，耗时很大，所以相同的时间复杂度的情况下，SPFA 实际上更耗时了。

拓展四（能否用dijkstra）

本题能否使用 dijkstra 算法呢？

dijkstra 是贪心的思路每一次搜索都只会找距离源点最近的非访问过的节点。

如果限制最多访问k个节点，那么 dijkstra 未必能在有限次就能到达终点，即使在经过k个节点确实可以到达终点的情况下。

这么说大家会感觉有点抽象，我用 dijkstra朴素版精讲里的示例在举例说明：（如果没看过我讲的dijkstra朴素版精讲，建议去仔细看一下，否则下面讲解容易看不懂）

在以下这个图中，求节点1 到节点7 最多经过2个节点的最短路是多少呢？

最短路显然是：

最多经过2个节点，也就是3条边相连的路线：节点1 -> 节点2 -> 节点6-> 节点7

如果是 dijkstra 求解的话，求解过程是这样的：（下面是dijkstra的模拟过程，我精简了很多，如果看不懂，一定要先看dijkstra朴素版精讲）

初始化如图所示：

找距离源点最近且没有被访问过的节点，先找节点1

距离源点最近且没有被访问过的节点，找节点2：

距离源点最近且没有被访问过的节点，找到节点3：

距离源点最近且没有被访问过的节点，找到节点4：

此时最多经过2个节点的搜索就完毕了，但结果中minDist[7] （即节点7的结果）并没有被更。

那么 dijkstra 会告诉我们节点1 到节点7 最多经过2个节点的情况下是不可到达的。

通过以上模拟过程，大家应该能感受到 dijkstra 贪心的过程，正是因为贪心，所以 dijkstra 找不到节点1 -> 节点2 -> 节点6-> 节点7 这条路径。

方法一： Bellman_ford


import sys

def main():
    input = sys.stdin.read
    data = input().split()
    
    N, M = int(data[0]),int(data[1])
    
    minDest = [float('inf')] * (N+1)
    hashmap = []

    index = 2

    for i in range(M):
        start = int(data[index])
        to = int(data[index+1])
        val = int(data[index+2])
        hashmap.append([start, to, val])
        index += 3
    
    src, dst, k = int(data[index]),int(data[index+1]),int(data[index+2])
    minDest[src] = 0
    for _ in range(k+1):
        minDest_copy = minDest.copy()
        flag = False
        for edge in hashmap:
            start, end, val = edge
            if minDest_copy[start] != float('inf') and minDest_copy[start] + val < minDest[end]:
                minDest[end] = minDest_copy[start] + val
                flag = True
        if flag == False:
            break
    if minDest[dst] == float('inf'):
        print('unreachable')
    else:
        print(minDest[dst])
    return

main()