题目详情

题目的大意是这样的：在一个洞穴中有n件宝物，每个宝物有重量、价值以及距离属性。所谓的距离属性是指从任意一个地方到这个宝物的位置需要耗费的路程时间。洞穴中除了宝物，还有一个魔王，魔王最开始是处于沉睡状态的，一旦魔王苏醒后，探险者将被魔王杀害而无法出洞，魔王的睡眠时间是wakeTime。此外，探险者拥有一个背包，背包的最大容量是packageSize，他可以采集任意的宝物，而且采集一个宝物的时间需要耗费1。

问题是：如何在魔王苏醒时间之前采集到价值尽量大的宝物，要求采集到的宝物总重量不能超出背包容量，结果需要输出可以采集到的宝物id数组。

题解分析

解法一：01背包问题+记录路径

1. 本题是典型的背包问题，但是情景相对更加复杂，因为除了重量和价值属性，宝物还具有时间属性，所以这不能使用传统的二维dp来求解。
2. 本题可以使用一个三维数组来记录动态状态，假设动态规划方程定义为：int[][][] dp，其中，dp[i][j][k]表示选第i个宝物背包容量为j时间为k的最大价值。动态转移方程如下：

3. 本题还有一个难点就是，题目并不是返回最大价值，而是满足条件的路径。所以，这里还需要记录路径。
4. 记录路径有两种方法，一种方法是使用parent数组，这种方法的缺点是需要额外定义一个类用于存放三个下标。

package interview;

import java.util.LinkedList;

/**
 * @Author WaleGarrett
 * @Date 2022/3/26 14:59
 */
// 6,10,
// [[1, 2, 4, 3], [2, 3, 2, 2], [3, 4, 1, 4], [4, 1, 1, 9]]
public class King {
    static class Gene{
        int i, j, k;
        Gene(){}
        Gene(int _i, int _j, int _k){
            i = _i;
            j = _j;
            k = _k;
        }
    }
    /**
     * 求在魔王苏醒之前，可以获取到价值最高的宝物列表；
     * @param packageSize int整型 背包容量
     * @param wakeTime int整型 魔王睡醒时长
     * @param treasureInfo int整型二维数组 宝物信息数组；宝物信息数组；[[宝物id, 宝物距离, 宝物重量, 宝物价值]]
     * @return int整型一维数组
     */
    public static int[] getTreasures(int packageSize, int wakeTime, int[][] treasureInfo) {
        // dp[i][j][k]表示选第i个宝物背包容量为j时间为k的最大价值
        // dp[i][j][k] = max(dp[i-1][j][k], dp[i-1][j-weight[i]][k-1-time[i]]);
        int n = treasureInfo.length;
        int[][][]dp = new int[n+1][packageSize+1][wakeTime+1];
        int[] weight = new int[n];
        int[] time = new int[n];
        int[] value = new int[n];
        for(int i=0; i<n; i++){
            weight[i] = treasureInfo[i][2];
            time[i] = treasureInfo[i][1];
            value[i] = treasureInfo[i][3];
        }
        Gene[][][] parent = new Gene[n+1][packageSize+1][wakeTime+1];
        for(int i=1; i<=n; i++){
            for(int j=0; j<=packageSize; j++){
                if(j < treasureInfo[i-1][2]){
                    for(int k=0; k<=wakeTime; k++) {
                        dp[i][j][k] = dp[i-1][j][k];
                        parent[i][j][k] = new Gene(i - 1, j, k);
                    }
                    continue;
                }
                for(int k=0; k<=wakeTime; k++){
                    if(k < (1 + time[i-1])){
                        parent[i][j][k] = new Gene(i - 1, j, k);
                        dp[i][j][k] = dp[i-1][j][k];
                        continue;
                    }
                    if(dp[i-1][j-weight[i-1]][k-1-time[i-1]] + value[i-1] > dp[i-1][j][k]){
                        dp[i][j][k] = dp[i-1][j-weight[i-1]][k-1-time[i-1]] + value[i-1];
                        parent[i][j][k] = new Gene(i - 1, j - weight[i - 1], k - 1 - time[i - 1]);
                    }else{
                        dp[i][j][k] = dp[i-1][j][k];
                        parent[i][j][k] = new Gene(i - 1, j, k);
                    }
                }
            }
        }
        LinkedList<Integer> sta = new LinkedList<>();
        Gene now = new Gene(n, packageSize, wakeTime);
        while(now.i != 0 && now.j != 0 && now.k != 0){
            Gene par = parent[now.i][now.j][now.k];
            if(dp[now.i][now.j][now.k] != dp[par.i][par.j][par.k]){
                sta.push(now.i);
            }
            now = par;
        }
        int[] res = new int[sta.size()];
        int num = 0;
        while(!sta.isEmpty()){
            res[num++] = sta.poll();
        }

        return res;
    }

    public static void main(String[] args) {
        int[] res = getTreasures(6, 10, new int[][]{{1, 2, 4, 3}, {2, 2, 2, 2}, {3, 4, 1, 4}, {4, 5, 1, 9}});
        for(int i : res){
            System.out.println(i);
        }
    }
}

5. 除了使用parent数组，我们还可以仔细观察一下动态转移方程。因为每次我们考虑问题都是放或者不放当前的宝物，所以，我们可以使用一个三维数组来记录是否放当前宝物。然后，为了输出路径，我们可以倒叙遍历i,j,k，并且在遍历到某个宝物确实是放在背包时，我们需要减去当前宝物的时间和重量依次来更新j,k。从而，我们可以使用一个栈来记录路径。

package interview;

import java.util.LinkedList;

/**
 * @Author WaleGarrett
 * @Date 2022/3/26 14:59
 */
// 6,10,
// [[1, 2, 4, 3], [2, 3, 2, 2], [3, 4, 1, 4], [4, 1, 1, 9]]
public class King {
    /**
     * 求在魔王苏醒之前，可以获取到价值最高的宝物列表；
     * @param packageSize int整型 背包容量
     * @param wakeTime int整型 魔王睡醒时长
     * @param treasureInfo int整型二维数组 宝物信息数组；宝物信息数组；[[宝物id, 宝物距离, 宝物重量, 宝物价值]]
     * @return int整型一维数组
     */
    public static int[] getTreasures(int packageSize, int wakeTime, int[][] treasureInfo) {
        // dp[i][j][k]表示选第i个宝物背包容量为j时间为k的最大价值
        // dp[i][j][k] = max(dp[i-1][j][k], dp[i-1][j-weight[i]][k-1-time[i]]);
        int n = treasureInfo.length;
        int[][][]dp = new int[n+1][packageSize+1][wakeTime+1];
        int[] weight = new int[n];
        int[] time = new int[n];
        int[] value = new int[n];
        for(int i=0; i<n; i++){
            weight[i] = treasureInfo[i][2];
            time[i] = treasureInfo[i][1];
            value[i] = treasureInfo[i][3];
        }
        boolean[][][] flag = new boolean[n+1][packageSize+1][wakeTime+1];
        for(int i=1; i<=n; i++){
            for(int j=0; j<=packageSize; j++){
                if(j < treasureInfo[i-1][2]){
                    for(int k=0; k<=wakeTime; k++) {
                        dp[i][j][k] = dp[i-1][j][k];
                    }
                    continue;
                }
                for(int k=0; k<=wakeTime; k++){
                    if(k < (1 + time[i-1])){
                        dp[i][j][k] = dp[i-1][j][k];
                        continue;
                    }
                    if(dp[i-1][j-weight[i-1]][k-1-time[i-1]] + value[i-1] > dp[i-1][j][k]){
                        dp[i][j][k] = dp[i-1][j-weight[i-1]][k-1-time[i-1]] + value[i-1];
                        flag[i][j][k] = true;
                    }else{
                        dp[i][j][k] = dp[i-1][j][k];
                    }
                }
            }
        }
        LinkedList<Integer> sta = new LinkedList<>();
        int i= n, j = packageSize, k = wakeTime;
        while(i > 0 && j>0 && k > 0){
            if(flag[i][j][k]){
                j -= weight[i-1];
                k -= (1 + time[i-1]);
                sta.push(i);
            }
            i--;
        }

        int[] res = new int[sta.size()];
        int num = 0;
        while(!sta.isEmpty()){
            res[num++] = sta.poll();
        }

        return res;
    }

    public static void main(String[] args) {
        int[] res = getTreasures(6, 10, new int[][]{{1, 2, 4, 3}, {2, 2, 2, 2}, {3, 4, 1, 4}, {4, 5, 1, 9}});
        for(int i : res){
            System.out.println(i);
        }
    }
}