有趣的算法题之购物单

购物单

王强决定把年终奖用于购物，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：

主件	附件
电脑	打印机，扫描仪
书柜	图书
书桌	台灯，文具
工作椅	无

如果要买归类为附件的物品，必须先买该附件所属的主件，且每件物品只能购买一次。

每个主件可以有 0 个、 1 个或 2 个附件。附件不再有从属于自己的附件。

王强查到了每件物品的价格（都是 10 元的整数倍），而他只有 N 元的预算。除此之外，他给每件物品规定了一个重要度，用整数 1 ~ 5 表示。他希望在花费不超过 N 元的前提下，使自己的满意度达到最大。

满意度是指所购买的每件物品的价格与重要度的乘积的总和，假设设第𝑖i件物品的价格为 𝑣[ 𝑖 ] ，重要度为 𝑤[ 𝑖 ] ，共选中了 𝑘 件物品，编号依次为 𝑗1,𝑗2,...,𝑗𝑘 则满意度为：𝑣[ 𝑗1 ]∗𝑤[ 𝑗1 ] + 𝑣[ 𝑗2] ∗𝑤[ 𝑗2 ] +…+ 𝑣[ 𝑗𝑘 ]∗𝑤[ 𝑗𝑘 ] 。

请你帮助王强计算可获得的最大的满意度。

原题链接：购物单_牛客题霸_牛客网 (nowcoder.com)

格式

输入描述：

输入的第 1 行，为两个正整数 N，m ，用一个空格隔开：

（其中 N （ N<32000 ）表示总钱数， m （m <60 ）为可购买的物品的个数。）

从第 2 行到第 m+1 行，第 j 行给出了编号为 j-1 的物品的基本数据，每行有 3 个非负整数 v p q

（其中 v 表示该物品的价格（ v<10000 ）， p 表示该物品的重要度（ 1 ~ 5 ）， q 表示该物品是主件还是附件。如果 q=0 ，表示该物品为主件，如果 q>0 ，表示该物品为附件， q 是所属主件的编号）

输出描述：

 输出一个正整数，为张强可以获得的最大的满意度。

样例

输入：

        1000 5
        800 2 0
        400 5 1
        300 5 1
        400 3 0
        500 2 0

输出：

        2200

 

输入：

        50 5
        20 3 5
        20 3 5
        10 3 0
        10 2 0
        10 1 0

输出：

        130

说明：

        由第 1 行可知总钱数 N 为 50 以及希望购买的物品个数 m 为 5 ；
        第 2 和第 3 行的 q 为 5 ，说明它们都是编号为 5 的物品的附件；
        第 4~6 行的 q 都为 0 ，说明它们都是主件，它们的编号依次为 3~5 ；
        所以物品的价格与重要度乘积的总和的最大值为 10*1 + 20*3 + 20*3 = 130  。

思路分析

        首先，我们需要明确题目要求我们解决的核心问题：在给定预算下最大化满意度。满意度由物品的价格和重要度共同决定，而物品分为主件和附件，附件必须随主件一起购买。

0 - 1 背包压缩数组模版

public int bag(int N, int[] weights, int[] values) {
     // 初始化动态规划数组
    int[] dp = new int[N + 1];

    // 遍历每个物品
    for (int i = 0; i < weights.length; i++) {
        // 从后往前遍历容量，避免重复购买
        for (int j = N; j >= weights[i]; j--) {
            // 更新dp数组
            dp[j] = Math.max(dp[j], dp[j - weights[i]] + values[i]);
        }
    }

     // 返回最大值
    return dp[N];
}

初始化动态规划数组

        接下来，我们初始化一个动态规划数组 dp ，其 p[ j ] 表示在预算为 j 时能获得的最大满意度。数组的长度为总预算加 1 ，初始值全为 0 。

构建销售组合

        由于附件必须随主件一起购买，我们不能简单地将每个物品视为独立的背包问题物品。因此，我们需要构建销售组合，将每个主件及其可能的附件组合成一个整体，作为一个独立的物品来处理。

        为什么这样构建呢？因为我们需要确保附件不会单独被购买，而只能通过购买其对应的主件来购买。构建销售组合后，我们就可以利用背包问题的解法来找到最大满意度。

动态规划求解

        为什么要使用动态规划呢？因为这个问题具有重叠子问题和最优子结构的特点。对于每个预算值，我们需要找到最大的满意度，而这个问题可以分解为更小的子问题：在给定预算下，购买哪些物品可以获得最大满意度？动态规划允许我们保存并重用这些子问题的解，从而避免重复计算。

        在更新 dp 数组时，我们采用从后往前遍历预算的方式。这是为了确保在计算 dp[ j ] 时，dp[ j - price ] 的值是上一轮的，数据没有被这一轮计算覆盖过，这样可以避免重复购买同一个物品。

        现在，我们遍历每个销售组合，并根据每个组合的价格和满意度来更新 dp 数组。

更新公式为：dp[ j ] = Math.max( dp[ j ],  dp[ j - v ] + s ) 。这里，v 和 s 分别表示当前销售组合的价格和满意度。我们比较不购买当前组合时的最大满意度（ dp[ j ] ）和购买当前组合后的最大满意度（ dp[ j ], dp[ j - v ] + s ），取两者中的较大值作为新的 dp[ j ] 。

代码

import java.util.Scanner;
import java.util.*;

public class Main {
    static int[] dp; // 预算数组
    static int[][] arr; // 物品数据
    static int n, m; // 总钱数，物品总数
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt(); // 总钱数
        m = in.nextInt(); // 物品总数
        dp = new int[n+1]; // 对应钱数能得到的最大满意度
        arr = new int[m+1][6]; // 物品数据
        
        // 处理物品数据
        // arr[i][3] 表示物品附件数，初始为 0
        // arr[i][4] 表示附件 1 的编号
        // arr[i][5] 表示附件 2 的编号
        for (int i = 1;i <= m;i++) {
            arr[i][0] = in.nextInt(); // 价格
            arr[i][1] = in.nextInt()*arr[i][0]; // 满意度
            arr[i][2] = in.nextInt(); // 主件编号
            int father = arr[i][2]; // 得到所属主件编号
            // 不为 0 ,说明为附件
            if (father != 0) {
                arr[father][3]++; // 主件所拥有的附件数加 1
                int childNum = arr[father][3]; // 获取主件拥有的附件数
                arr[father][3+childNum] = i; // 存储附件编号
            }
        }
        
        // 遍历每一个物品
        for (int i = 1;i <= m;i++) {
            if (arr[i][2] != 0) continue; // 跳过附件，因为在遍历主件时会带上附件
            int[][] cur = new int[4][2]; // 可销售组合，最多有 4 种组合
            cur[0][0] = arr[i][0]; // 主件价格
            cur[0][1] = arr[i][1]; // 主件满意度
            int childNum = arr[i][3]; // 附件个数
            if (childNum == 1) {
                int index = arr[i][4]; // 附件编号
                cur[1][0] = arr[index][0] + cur[0][0]; // 附件+主件价格
                cur[1][1] = arr[index][1] + cur[0][1]; // 附件+主件满意度
            }else if (childNum == 2) {
                int index = arr[i][4]; // 附件1编号
                cur[1][0] = arr[index][0] + cur[0][0]; // 附件1+主件价格
                cur[1][1] = arr[index][1] + cur[0][1]; // 附件1+主件满意度
                index = arr[i][5]; // 附件2编号
                cur[2][0] = arr[index][0] + cur[0][0]; // 附件2+主件价格
                cur[2][1] = arr[index][1] + cur[0][1]; // 附件2+主件满意度
                cur[3][0] = cur[1][0] + cur[2][0] - cur[0][0]; // 附件1+附件2+主件价格
                cur[3][1] = cur[1][1] + cur[2][1] - cur[0][1]; // 附件1+附件2+主件满意度
            }
            
            // 压缩为一维数据，从后往前遍历可以防止重复购买
            for (int j = n;j >= 0;j--) {
                // 列举销售组合
                for (int k = 0;k < 4;k++) {
                    // 防止数组越界
                    if (j >= cur[k][0]) {
                        dp[j] = Math.max(dp[j], dp[j - cur[k][0]] + cur[k][1]);
                    }
                }
            }
        }
        
        // 输出答案
        System.out.println(dp[n]);
    }
}

结果

最后

---

如果有所收获请点赞支持一下作者哦，您的点赞是我持续创作的动力！！