边数限制的最短路Bellmax_ford个人见解

用来计算（有边数限制的）负权最短路

算法思想：

题目：

输入格式
第一行包含三个整数n，m，k。
接下来m行，每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。
输出格式
输出一个整数，表示从1号点到n号点的最多经过k条边的最短距离。
如果不存在满足条件的路径，则输出“impossible”。

举例子

推荐模拟网址https://csacademy.com/app/graph_editor/

 如果用dijksra算法的话

过程应该是

选择1号节点， 更新点1号节点

选择2号节点，更新2号节点

最后选择4号节点

最短路则为2+1=3；

但是实际最短路应该是 3-2 = 1

故dj无法处理负权问题

而Bellman则不同，bellman的时间复杂度是O（n*m）

板子是

 for(int i = 1;i<=k;i++)
    {
        memcpy(backup,dist,sizeof dist);
        for(int j = 1;j<=m;j++)
        {
            int x = s[j].x, y = s[j].y, z = s[j].z;
            dist[y] = min(dist[y],back[x]+z);
        }
    }

外层for循环可以理解为边数

back[] 数组是上一次迭代后 dist[] 数组的备份，由于是每个点同时向外出发，因此需要对 dist[] 数组进行备份，若不进行备份会因此发生串联效应，影响到下一个点

在下面代码中，是否能到达n号点的判断中需要进行if(dist[n] > INF/2)判断，而并非是if(dist[n] == INF)判断，原因是INF是一个确定的值，并非真正的无穷大，会随着其他数值而受到影响，dist[n]大于某个与INF相同数量级的数即可

    if(dist[n] >= 0x3f3f3f3f/2) printf("impossible");
    else printf("%d", dist[n]);

 完整代码

#include<stdio.h>
#include<iostream>
#include<queue>
#include<stack>
#include<math.h>
#include<string.h>
#include<map>
#include<algorithm>
#define long long intt
#define MAX 0x3f
#define clean(a,x) memset(a,x,sizeof(a))//万年不变头文件
using namespace std;
const int maxn=1e4;
int n, m, k;
int dist[maxn];
int back[maxn];

struct edge{
    int a;
    int b;
    int w;
}edges[maxn];

int bellman_ford(){
    clean(dist, 0x3f);
    dist[1] = 0;
    for(int i=1;i<=k;i++){
        memcpy(back, dist, sizeof(dist));
        for(int j=1;j<=m;j++){
            int a = edges[j].a, b = edges[j].b, w = edges[j].w;
            dist[b] = min(dist[b], back[a] + w);
        }
    }
    if(dist[n] >= 0x3f3f3f3f/2) printf("impossible");
    else printf("%d", dist[n]);
}

int main(){
    scanf("%d %d %d", &n, &m, &k);
    for(int i=1;i<=m;i++){
        scanf("%d %d %d", &edges[i].a, &edges[i].b, &edges[i].w);
    }
    bellman_ford();
}
 

 有错再改

另外附上一副back数组变化，方便理解