lintcode：562 · 背包问题 IV

题目来源

• lintcode

题目描述

class Solution {
public:
    /**
     * @param nums: an integer array and all positive numbers, no duplicates
     * @param target: An integer
     * @return: An integer
     */
    int backPackIV(vector<int> &nums, int target) {
        // write your code here
    }
};

题目解析

要求刚好装满，类似的题目有：

• 爬楼梯问题，每次可以爬1级或2级，求总共有多少种方法爬到顶
• 机器人从网格的左上角走到右下角，每次可以向右或向下一格，求有多少种路径到达右下角

物品有无限个，说明是完全背包问题。

完全背包

（1）状态：

• 一般这种题目的状态是到底当前状态，有多少种方式。
• 这里要求填满背包的方案数，假设背包容量为3，物品重量为[1,2]，那么[1,2], [2,1]只能算是一种方案
• 状态：dp[i][j]表示前i件物品，在容量为j的背包下，有几种方案
• 我们在计算dp[i+1][?]的时候，由于物品A[j]是新加入的，所以不会存在[1，2]、[2，1]这种方案重复的情况

（2）转移方程

• 有多少个状态能转移到dp[i][j]，那么dp[i][j]就应该是多少，也就是表示有多少种方案
• 此外，由于每种物品没有数量显示，因此我们还需要循环物品数量k

最后一个不选上：dp[i][j] = dp[i-1][j]
最后一个选上：dp[i][j] = sum（dp[i-1][j-k*nums[i-1]]）;

（3）边界情况

• 必须对dp[i][0]的情况都赋值为1，这表示背包容量为0的情况下，有一种方案
• dp[0][j] 表示0个物品填满容量为j的背包，由于物品数为0，无法填满，因此dp[0][j]应该为0

（4）计算顺序

• 从上到下，从左到右
• 答案是dp[n][target]

class Solution {
public:
    int backPackIV(vector<int> &nums, int target) {
        int n = nums.size();
        std::vector<std::vector<int>> dp(n + 1, std::vector<int>(target + 1));
        for (int i = 0; i <= n; i++) {
            dp[i][0] = 1;  //背包容量为0时，有一种方案填满
        }

        for (int i = 1; i <= n; i++ ) {  // 对于每一个物品
            int item = nums[i-1]; //当前物品重量
            for (int j = 0; j <= target; j++) {  // 对于每一个重量
                for (int k = 0; k  * item <= j; ++k) {  // 可以存放多少个
                    dp[i][j] += dp[i - 1][j - k * item];
                }
            }
        }


        return dp[n][target];
    }
};

优化：

class Solution {
public:
    int backPackIV(vector<int> &nums, int target) {
        // write your code here
        int n = nums.size();


        std::vector<std::vector<int>> dp(n + 1, std::vector<int>(target + 1));
        for (int i = 0; i <= n; i++) {
            dp[i][0] = 1;
        }

        for (int i = 1; i <= n; i++ ) {
            int item = nums[i-1]; //当前物品重量
            for (int k = 1; k <= target; k++) {
                dp[i][k] = dp[i-1][k];  // 不装时，也就是只考虑前i-1个物品，背包重量为k时的方案数量
                if (k >= item) {
                    dp[i][k] += dp[i][k - item]; // 装时，考虑前i个物品，背包重量为k - item时的方案数量
                }
            }
        }


        return dp[n][target];
    }
};

（4）状态压缩

• 先物品然后状态：
  • 我们无需关心每个状态包含了多少物品，只要加上前一个状态的方案数量即可
  • 由于物品在外层循环，也不会发生[1,2], [2,1]这样的重复问题

class Solution {
public:
    int backPackIV(vector<int> &nums, int target) {
        int n = nums.size();
        std::vector<int> dp (target + 1);  // 对每一个重量有几种方案能够装满
        dp[0] = 1;  //当背包重量为0时，只有一种方案可以装满
        
        for (int i = 0; i < n; ++i) {   // 对于每一个物品
            int item = nums[i];  // 当前物品重量
            for (int j = item; j <= target; ++j) { // 重量
                dp[j] += dp[j - item];
            }
        }

        return dp[target];
    }
};

class Solution {
public:
    int backPackIV(vector<int> &nums, int target) {
        int n = nums.size();
        std::vector<int> dp (target + 1);  // 对每一个重量有几种方案能够装满
        dp[0] = 1;  //当背包重量为0时，只有一种方案可以装满
        for (int i = 1; i <=  target; ++i) {  // 对于每一个重量
            for (int j = 0; j < n; ++j) {  //看是否有物品可以装满
                int item = nums[j];
                if(item <= i){ // 能够放入
                    dp[i] += dp[i - item];
                }
            }
        }

        return dp[target];
    }
};