Bellman-ford算法（有边数限制的最短路）

题目

给定一个 n个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出从 1 号点到 n 号点的最多经过 k条边的最短距离，如果无法从 1号点走到 n号点，

输出 impossible。

注意：图中可能 存在负权回路 。

---

输入格式

第一行包含三个整数 n,m,k。

接下来 m 行，每行包含三个整数 𝑥,𝑦,𝑧，表示存在一条从点 𝑥 到点 𝑦 的有向边，边长为 𝑧。

点的编号为 1∼𝑛。

---

输出格式

输出一个整数，表示从 1号点到 𝑛 号点的最多经过 𝑘 条边的最短距离。

如果不存在满足条件的路径，则输出 impossible。

---

数据范围

1≤n,k≤500,
1≤m≤10000,
1≤x,y≤n，
任意边长的绝对值不超过 10000。

---

输入样例：

3 3 1
1 2 1
2 3 1
1 3 3

---

输出样例：

3

---

 核心思想

使用结构体存储a,b,w

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

1、d[1]  = 0,d[i] = 正无穷

2、for  i  遍历k次   

        对d[]进行备份到g[]

                for i 遍历 所有边  a,b,w  a指向b，w是权重

                        d[b] = min(d[b],g[a]+w);

---

分析题目

题目要求输出从1到n经过k条边的最短距离是多少，因此有边数限制，我们需要遍历k次,因为会发

生串联的现象，所以需要进行备份

1--->2 d = 1	2 --->3    d = 1
1	2	3
1---->3  d= 3

for  0~k

        for  0~m   

      

	1	2	3
d	0	0x3f3f3f3f	0x3f3f3f3f
不备份	0	1	2
备份	0	1	0x3f3f3f3f

---

相关代码

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 510,M = 1e6+10;
int n,m,k;
int d[N];//记录距离
int backup[N];//用于d[N]的备份

struct Edge{
  int a,b,w;//表示a--->b  权重是w；  
}edge[M];//用结构体数组来存储

int bellman_ford()
{
    memset(d,0x3f,sizeof d);//初始化
    d[1] =0;
    for(int i=0;i<k;i++)//遍历k次，有限制所以不会发生死循环或者负无穷
    {
        memcpy(backup,d,sizeof d);//对d的值进行备份，有边数限制，防止发生串联
        for(int j=0;j<m;j++)
        {
            int a = edge[j].a,b = edge[j].b,w = edge[j].w;
            d[b] = min(d[b],backup[a]+w);
        }
    }
    if(d[n] >0x3f3f3f3f/2)return 0x3f3f3f3f; 
    return d[n];
}

int main()
{
   scanf("%d%d%d",&n,&m,&k);
   for(int i=0;i<m;i++)
   {
       int a,b,w;
       scanf("%d%d%d",&a,&b,&w);
       edge[i] = {a,b,w};
   }
   int t = bellman_ford();
   if(t == 0x3f3f3f3f )puts("impossible");
   else printf("%d",t);
    
}

 欢迎大佬们来指点，嘻嘻