【蓝桥杯3542】魔法阵（线性dp&最短路径&spfa算法&java）

问题描述

输入输出

解题思路

此题的难点在于怎么把最短路径问题和动态规划问题结合起来。

代码中使用dp[v][kk]表示从第0点到第v点，使用魔法抵消kk点伤害后的最小伤害。

代码中使用了Edge存储边（类似结构体），但是只存了边的到达点和权值，而没有边的出发点，为什么呢？

因为在后面的动态规划中，需要根据起始点来遍历边，如果把起始点u也放入Edge，那么每次取边都需要遍历所有的边。

因此在数据结构上使用容器嵌套，Vector<Vector<Edge>> vector。代码中的vector.get(u).add(new Edge(v, w)); 代表边从u点到v点，权值为w。当需要遍历起始点为u的边时，只需要用for (Edge edge : vector.get(u))即可在循环中将起始点为u的边赋值给edge，再进行dp操作。

最短路径算法使用的是spfa算法，简单地来说就是类似bfs一样，将更改后的点放入队列中，通过入队出队实现dp遍历。（当然也可以不用队列，用几个for去遍历，较为繁琐）

再看一下dp，根据kk的值分为两种情况：

1.若kk<k，则kk+1<=k，那么一定是可以使用魔法的。因此更新使用魔法后的最小伤害。比如点1、2、3、4、5，k为2，那么第4点使用魔法可以是14、24、34（假设两两之间均有边连接），就是在比较哪个更小。

2.不使用魔法或魔法已经使用过，则相当于根据边更新最短路径。

同时，易知使用魔法受到的伤害一定小于等于不使用魔法受到的伤害，因此最终答案为dp[n - 1][k]。

AC代码

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Vector;

//相当于边的结构体
class Edge {
	int v, w; // v为到达点，w为权值

	public Edge(int v, int w) {
		this.v = v;
		this.w = w;
	}
}

public class Main {
	static int n, k, m; // n个结点，m条边，可免除k条边受到的伤害
	static Vector<Vector<Edge>> vector = new Vector<>(); // 用容器来存储边，嵌套是为了保证u、v关系

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		n = scan.nextInt();
		k = scan.nextInt();
		m = scan.nextInt();

		// 容器嵌套初始化
		for (int i = 0; i < n; i++) {
			vector.add(new Vector<>());
		}

		for (int i = 0; i < m; i++) {
			int u = scan.nextInt();
			int v = scan.nextInt();
			int w = scan.nextInt();
			vector.get(u).add(new Edge(v, w)); // 代表u点到v点，权值为w
			vector.get(v).add(new Edge(u, w)); // 代表v点到u点，权值为w
		}

		System.out.println(spfa());
		scan.close();
	}

	// 使用spfa算法获取最小伤害
	public static int spfa() {
		int[][] dp = new int[1005][15]; // 根据题目所给范围开大一点点，dp[v][kk]表示从第0点到第v点，使用魔法抵消kk点伤害后的最小伤害

		// 初始化为int最大值
		for (int i = 0; i < n; i++) {
			for (int j = 0; j <= k; j++) {
				dp[i][j] = Integer.MAX_VALUE;
			}
		}

		dp[0][0] = 0;// 第0点时还没受到伤害

		Queue<int[]> queue = new LinkedList<>();// 使用队列存储dp数组的坐标点，类似bfs达到遍历的效果
		queue.add(new int[] { 0, 0 });
		while (!queue.isEmpty()) {
			int[] pos = queue.poll();
			int u = pos[0], kk = pos[1];// u表示出发点，kk表示使用魔法抵消kk条边的伤害

			// 遍历u为出发点的每一条边
			for (Edge edge : vector.get(u)) {
				int v = edge.v, w = edge.w; // v为到达点，w为权值

				// 若kk<k，则kk+1<=k，那么一定是可以使用魔法的。因此更新使用魔法后的最小伤害。
				// 比如点1、2、3、4、5，k为2，那么第4点使用魔法可以是14、24、34（假设两两之间均有边连接），此处就是在比较哪个更小
				if (kk < k) {
					if (dp[v][kk + 1] > dp[u][kk]) {
						dp[v][kk + 1] = dp[u][kk];
						queue.add(new int[] { v, kk + 1 });
					}
				}

				// 若不使用魔法或魔法已经使用过，则相当于根据边更新最短路径
				if (kk == 0 || kk == k) {
					if (dp[v][kk] > dp[u][kk] + w) {
						dp[v][kk] = dp[u][kk] + w;
						queue.add(new int[] { v, kk });
					}
				}
			}
		}

		// 易知使用魔法受到的伤害一定小于等于不使用魔法受到的伤害
		return dp[n - 1][k];
	}
}

（by 归忆）