AcWing 853. 有边数限制的最短路

题目

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

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

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

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

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

点的编号为 $1∼n$。

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

如果不存在满足条件的路径，则输出 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

思路

基本思路：

for i in 1~n
    for a, b, w in i所有边  a到b的距离为w
	d[b] = min(d[b], d[a] + w[a][b])

注意：

1. 更新 $n$ 次后，对于所有边，满足 d[b] <= d[a] + w[a][b]
2. 迭代 $n$ 次就表示最多经过 $n$ 条边的最短距离，可以用来限制边数来求最短距离
3. 要在每次迭代时要备份，避免“串联”，比如一次迭代中更新了 $1$ --> $2$ 和 $2$ --> $3$，不备份的话后者会受前者影响

限制边数求最短路的情况只能用 bellman-ford 来求

代码

#include <iostream>
#include <cstring>

using namespace std;

const int N = 510, M = 10010;

struct Edge
{
    int a, b, c;
}edges[M];

int n, m, k;
int d[N], back_up[N];

void bellman_ford()
{
    memset(d, 0x3f, sizeof d);
    d[1] = 0;
    
    for (int i = 0; i < k; i ++ )
    {
        memcpy(back_up, d, sizeof d);
        for (int j = 0; j < m; j ++ )
        {
            auto e = edges[j];
            d[e.b] = min(d[e.b], back_up[e.a] + e.c);
        }
    }
    
    // 因为有可能d[n]答案确实是-1，所以这种返回不合适
    // if (d[n] > 0x3f3f3f3f / 2) return -1;
    
    // return d[n];
}

int main()
{
    scanf(%d%d%d, 
    
    for (int i = 0; i < m; i ++ )
    {
        int a, b, c;
        scanf(%d%d%d, 
        edges[i] = {a, b, c};
    }
    
    bellman_ford();
    if (d[n] > 0x3f3f3f3f / 2) puts(impossible);
    else printf(%d\n, d[n]);
    
    return 0;
}