搜索与图论 有边数限制的最短路 (Bellman-Ford算法)

有边数限制的最短路

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

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

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

输入格式
第一行包含三个整数 n,m,k。

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

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

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

数据范围
1≤ n,k ≤500,
1≤ m ≤10000,
任意边长的绝对值不超过 10000。

输入样例：

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

输出样例：

3

Bellman-Ford算法：解决单源含有负权边的最短路问题。
思想：
维护一个 dist[N] 数组，代表起点到 N 个点的最短距离。初始 dist[1]=0,dist[other]=＋∞。

1. 将起点可直达的所有点的距离，存入 dist 。
2. 利用dist去 更新上述点可直达的点(起点两步可以到达的点) 的距离，更新 dist，此时dist中存储的为经过小于等于两步可以到达的点的最短距离。
3. 重复第2步骤，更新 dist，此时dist中存储的为经过小于等于三步可以到达的点的最短距离。（每重复一次相当于多走一条边）
4. 直到重复m次（经过所有的边更新的）dist 中存储着的就是起点到所有点的最短路。

C++

#include<bits/stdc++.h>
using namespace std;
const int N = 510,M=10010;
int n,m,k,d[N],back[N];
struct Edge //存储图中a点指向b点，权值为w的边。
{
    int a,b,w;
}edges[M];
int main()
{
    cin>>n>>m>>k;
    memset(d,0x3f,sizeof d);
    d[1]=0;
    for(int i=0;i<m;i++)
    {
        int a,b,w;
        cin>>a>>b>>w;
        edges[i]={a,b,w};
    }
    while(k--)
    {
        memcpy(back,d,sizeof d); //back为备份数组，记录上一次更新过的d数组（即目前已知起点可直达的点的距离），防止串联更新。
        for(int i=0;i<m;i++)
        {
            int a=edges[i].a,b=edges[i].b,w=edges[i].w;
            d[b]=min(d[b],back[a]+w);
        }
        
    }
    if(d[n]>0x3f3f3f3f/2) puts("impossible");
    else cout<<d[n]<<endl;
    return 0;
}

使用邻接矩阵存储图：(因为Bellman-Ford的遍历与边数有关，使用邻接矩阵存储在遍历时是以点遍历的，相对而言更费时间)

#include<bits/stdc++.h>
using namespace std;
const int N = 510;
int n,m,k;
int a[N][N],d[N],back[N];
int main()
{
    cin>>n>>m>>k;
    memset(a,0x3f,sizeof a),memset(d,0x3f,sizeof d);
    for(int i=1;i<=n;i++) a[i][i]=0;
    d[1]=0;
    while(m--)
    {
        int x,y,z;
        cin>>x>>y>>z;
        a[x][y]=min(a[x][y],z);
    }
    while(k--)
    {
        memcpy(back,d,sizeof d);
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
                d[j]=min(d[j],back[i]+a[i][j]);
        }
    }
    if(d[n]>0x3f3f3f3f/2) puts("impossible");
    else cout<<d[n]<<endl;
    return 0;
}