[题]有边数限制的最短路 —— 标签 #Bellman-Ford

# Bellman-Ford算法

853. 有边数限制的最短路

思路/大致模板：

*1 for n次
*2 每次 for 所有边 a —w-> b,（松弛操作）
(储存边的方式很广泛， 能走完所有边就可以了。）
*3 dist[b] = min(dist[b], dist[a] + w );
然后……………………
搞定！
循环后， 所有边一定满足 dist[b] <= dist[a] + w（三角不等式）
有负权回路的图不一定能求最短回路。

迭代n次的意义：

假设已经迭代了 k次， 那么dist[]数组的含义是从一号点 经过 不超过 k 条边走到每个点的最短距离。

时间复杂度 ： O(n*m）

例题代码：

#include<bits/stdc++.h>
using namespace std;
const int N = 510, M = 100010;
int n, m, k;
int dist[N], backup[N];

struct Edge{
    int a, b, w;
}e[M];

int brm(){
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    for(int i = 0; i < k; i ++){                    /* *17 */
        memcpy(backup, dist, sizeof dist);          /* *18 */
        for(int j = 0; j < m ; j ++){               /* *19 */
        //取出a, b, w;
            int a = e[j].a, b = e[j].b, w = e[j].w;
            dist[b] = min(dist[b], backup[a] + w);  /* *21 */
        }
    }

    if(dist[n] > 0x3f3f3f3f / 2)/* *25 */
        return -1;
    return dist[n];
}

int main(){
    cin >> n >> m >> k;

    for(int i = 0; i < m; i ++){
        int a, b, w;
        cin >> a >> b >> w;
        e[i] = {a, b, w};
    }
    int t = brm();
    if(t == -1) cout << "impossible" << endl;
    else cout << t;
    return 0;
}
/*bellman-ford 可以求出当经过的边不超过k条时的单源最短路。
*17 所以这里 0 <= i < k, 一共k次。
*18 备份上一轮的图；
*19 j将所有的边都遍历一遍；
*21 为了不 串联(这一轮走了两条边， 但理论上一轮只应该走一条边)，就要用上一轮的图；
	新的数据会保留在新的图里，当所有的边都遍历完之后再复制回去
*25 假设 1没有边可以经过5、8,dist[5]、dist[8]都是10^9(正无穷), 
	但是5到8的距离是2，那么dist[8]会被更新为 10^9-2, 就不再是正无穷。
	题目所限制的距离一般不会超过0x3f3f3f3f的一半。
*/

还有个第二版本

三、bellman-ford

bellman-ford 可以求出当经过的边不超过k条时的单源最短路。
并且可以处理负权边，因为没有那种按照最小值来的循环，每一次遍历都是固定的遍历所有的边……

#include<bits/stdc++.h>
using namespace std;
const int N = 510, M = 100010;
int n, m, k;
int dist[N], backup[N];

struct Edge{
    int a, b, w;
}e[M];

int brm(){
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
	//所以这里一共k次， 代表当前最多经过k条边
    for(int i = 0; i < k; i ++){ 
	    //备份上一轮的图；
        memcpy(backup, dist, sizeof dist); 
        //j将所有的边都遍历一遍；
        for(int j = 0; j < m ; j ++){
        	//取出a, b, w;
            int a = e[j].a, b = e[j].b, w = e[j].w;
            //尝试用当前边的 起点到源点的距离 来更新 终点到源点的距离。
            //这样可以保证不会有遗漏，因为所有的边都会遍历到
         	
         	//为了不 串联(这一轮走了两条边， 但理论上一轮只应该走一条边)，就要用上一轮的图；
			//新的数据会保留在新的图里,并且舍弃掉旧的副本
            dist[b] = min(dist[b], backup[a] + w); 
        }
    }
//	假设 1没有边可以经过5、8,dist[5]、dist[8]都是10^9(正无穷), 
//	但是5到8的距离是-2，那么dist[8]会被更新为 10^9-2, 就不再是正无穷。
//	题目所限制的距离一般不会超过0x3f3f3f3f的一半。
//		这就是为什么bell-ford可以处理负权！

	//这个条件满足就说明目标点没有办法到源点。
    if(dist[n] > 0x3f3f3f3f / 2) return -1;
    
    return dist[n];
}

int main(){
    cin >> n >> m >> k;

    for(int i = 0; i < m; i ++){
        int a, b, w;
        cin >> a >> b >> w;
        e[i] = {a, b, w};
    }
    int t = brm();
    if(t == -1) cout << "impossible" << endl;
    else cout << t;
    return 0;
}