有边数限制的最短路问题

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

首先我们注意到这里边权可能为负数，那么我们就不能使用之前的dijkstra算法进行求解，为什么呢？

如上图所示，如果我们使用dijkstra算法，那么我们的步骤如下所示：

1. 利用1号节点更新与之相连的节点，这里d[2] = 2, d[3] = 5
2. 然后我们从更新的节点中选取距离最近的点，加入最短路径，即2号点
3. 然后继续利用2号点更新距离，然后选取最近的点，即4号点，最后继续上述步骤选取五号点
4. 最终我们得到的序列应该是1->2->4->5,但是很明显1->3->4->5距离更短，因此dijkstra算法失效

这里我们应该多角度考虑问题，而不能每次只选择当前最小，这样的一锤子买卖.

因此，我们引出了bellman-ford算法，代码难度较小。时间复杂度为O（nm）

for n :
	for i in m:(对边(a, b) = w进行松弛操作)
		dist[b] = Math.min(dist[b], backup[a] + w;

上述题目代码实现如下所示：

import java.io.*;
import java.util.*;

public class Main{
    public static int[] backup = new int[100010];
    public static int[] d = new int[100010];
    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] lens = br.readLine().split(" ");
        int n = Integer.parseInt(lens[0]);
        int m = Integer.parseInt(lens[1]);
        int k = Integer.parseInt(lens[2]);
        ArrayList<int[]> list = new ArrayList<>();
        for (int i = 0; i < m; i++){
            String[] res =br.readLine().split(" ");
            int a = Integer.parseInt(res[0]);
            int b = Integer.parseInt(res[1]);
            int c = Integer.parseInt(res[2]);
            list.add(new int[]{a, b, c});
        }
        int t = bellman_ford(n, m, k, list);
        if (t == -1) System.out.println("impossible");
        else System.out.println(t);
    }
    public static int bellman_ford(int n, int m, int k, ArrayList<int[]> list){
        Arrays.fill(d, 0x3f3f3f3f);
        d[1] = 0;
        for (int i = 0; i < k; i++){
            backup = Arrays.copyOf(d, n + 1);
            for (int j = 0; j < m; j++){
                int[] x = list.get(j);
                int a = x[0];
                int b = x[1];
                int c = x[2];
                d[b] = Math.min(d[b], backup[a] + c);
            }
        }
        if(d[n] > 0x3f3f3f3f / 2) return -1;
        else return d[n];
    }
}

参考Acwing题解