背包问题:01背包+完全背包+有关题目

一、01背包问题详解

1. 确定dp数组以及下标的含义

dp[ i ] [ j ] 表示前 i 件物品放入一个容量为 j 的背包可以获得的最大价值（每件物品最多放一次）

2. 确定递推公式

3. dp数组的初始化
   首先从dp[i][j] 的定义出发，如果背包容量j为0的话，即dp [i] [0] ，无论是选取哪些物品，背包价值总和一定为0。如图：
   

• 状态转移方程 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 可以看出i 是由 i-1 推导出来，那么i为0的时候就一定要初始化。 dp[0][j]，即：i为0，存放编号0的物品的时候，各个容量的背包所能存放的最大价值。
• 那么很明显当 j < weight[0]的时候，dp[0][j] 应该是 0，因为背包容量比编号0的物品重量还小。
• 当j >= weight[0]时，dp[0][j] 应该是value[0]，因为背包容量放足够放编号0物品。
  

function testWeightBagProblem (weight, value, size) {
    // 定义 dp 数组，物品的数量为行，背包的不同容量为列（注意由于可以不放，所以是size+1）
    const dp = Array(weight.length).fill().map(() => Array(size + 1).fill(0));

    // 初始化,对于物品0，放入不同容量背包的最大价值
    // j就代表不同的容量，最大为背包的最大容量。
    for(let j = weight[0]; j <= size; j++) {
        dp[0][j] = value[0];
    }

    // 对于每个物品，放入不同的背包里的最大价值。
    // 由于上面已经把物品0的可能性列出了，所以这里从物品1开始
    for(let i = 1; i < weight.length; i++) { 
        // 不同的背包容量，从0开始
        for(let j = 0; j <= size; j++) { 
            // 如果背包的容量不能放下物品，此时的最大价值就是上一个状态的
            if(j < weight[i]) dp[i][j] = dp[i - 1][j];
            // 否则就是比较放入物品i 和 不放入物品的i 这两种情况的最大价值
            else dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
        }
    }
    
    return dp[len - 1][size];
}

function test () {
    console.log(testWeightBagProblem([1, 3, 4, 5], [15, 20, 30, 55], 6));
}

test();

下面两个题目里的数组都是代表物品的重量，不涉及物品的价值。

416. 分割等和子集

题目链接

var canPartition = function(nums) {
    let n = nums.length

    // 两个子集的和等于总和的一半，所以如果总和为奇数，那么就是false
    let sum = 0
    for(const s of nums){
        sum += s
    }
    // 总和无法等分一定为false
    if(sum % 2 != 0) return false

    // 目标和，即背包容量
    const targetSum = sum / 2

    // 如果有物品的重量大于目标和，则为fasle
    if(Math.max(...nums) > targetSum) return false


    // 转换为01背包问题，即从nums（物品）里选择出的数字等于targetSum（背包的容量）
    // 1、dp数组,初始化全为false
    let dp = new Array(n+1).fill().map(() => new Array(targetSum+1).fill(false))

    // 2、初始化
    dp[0][0] = true

    // 状态更新
    for(let i = 1; i <= n; i++) { 
        for(let j = 0; j <= targetSum; j++) { 
            if(j < nums[i-1]) dp[i][j] = dp[i - 1][j];
            else dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i-1]];
        }
    }
    return dp[n][targetSum]
};

494. 目标和

题目链接
假设所有符号为+的元素和为x，符号为-的元素和的绝对值是y。

• 我们想要的 S = 正数和 - 负数和 = x - y
• 已知x与y的和是数组总和：x + y = sum
• 可以求出 x = (S + sum) / 2 = target，问题为从nums数组里选出几个数，令其和为target。

比如nums = [1,1,1,1,1], target = 3。-1 + 1 + 1 + 1 + 1 = 3 中所有符号为+的元素为4，-的元素的1。所以正数和4 - 负数和1 = 3.

var findTargetSumWays = function(nums, target) {
    // 求数组和sum,检查sum和target的关系，考虑为0的时候
    let sum = 0
    for (const s of nums){
        sum += s
    }
    // 
    const diff = sum - target;
    if (diff < 0 || diff % 2 !== 0) {
        return 0;
    }
    const n = nums.length, neg = diff / 2;

     // 01背包问题，转换为从nums里选若干个数放到容量为neg的背包里
    const dp = new Array(n + 1).fill(0).map(() => new Array(neg + 1).fill(0));
    dp[0][0] = 1

    // 状态更新
    for(let i=1; i<=n; i++){
        for(let j=0; j<=neg; j++){
            if(j < nums[i-1]){  // 容量不够，放不下
                dp[i][j] = dp[i-1][j]
            }else{
                dp[i][j] = dp[i-1][j] + dp[i-1][j-nums[i-1]] // 第i个数字nums[i-1]
            }
        }
    }
    return dp[n][neg]
};

二、完全背包

322. 零钱兑换

题目链接
详解
这个题目和上面的两个01背包问题不一样，这个是涉及物品的价值的问题。物品的价值就是硬币的数量。初始化就是考虑dp[0][0] , dp[0][j], dp[i][0] 这三种情况。

var coinChange = function(coins, amount) {
    // 1、定义dp数组，因为要取最小值，所以不确定和不合法的都赋予最大值
    const n = coins.length
    const dp = new Array(n+1).fill().map(() => new Array(amount+1).fill(Infinity))

    // 2、初始化，dp[0][i]不合法设最大值
    dp[0][0] = 0

    // 3、遍历更新状态
    for(let i=1; i<=n; i++){
        for(let j=0; j<=amount; j++){
            // 容量有限，放不下,那么此时的状态还是未选择之前的状态
            if(j < coins[i-1]){
                dp[i][j] = dp[i-1][j]
            }else{
                dp[i][j] = Math.min(dp[i-1][j],dp[i][j-coins[i-1]] + 1)
            }
        }
    }
    return dp[n][amount] == Infinity ? -1 : dp[n][amount]
};

518. 零钱兑换 II

上个题目是硬币数的最小值，这个题目不涉及物品的价值，就是单纯的组合。所以进行稍微的改动即可。

var change = function(amount, coins) {
    // 1、定义dp数组
    const n = coins.length
    const dp = new Array(n+1).fill().map(() => new Array(amount+1).fill(0))

    // 2、初始化
    dp[0][0] = 1

    // 3、遍历更新状态
    for(let i=1; i<=n; i++){
        for(let j=0; j<=amount; j++){
            // 容量有限，放不下,那么此时的状态还是未选择之前的状态
            if(j < coins[i-1]){
                dp[i][j] = dp[i-1][j]
            }else{
                dp[i][j] = dp[i-1][j] + dp[i][j-coins[i-1]]
            }
        }
    }
    return dp[n][amount]
};

279. 完全平方数

题目

var numSquares = function(n) {
    // 此题对于物品是未知的，所以需要处理出一个小于n的完全平方数的集合
    let nums=[], i=1;
    while(i*i <= n){
        nums.push(i*i)
        i++
    }
    // 此时物品就是nums数组，背包容量就是n,问题就相当于零钱兑换1这个题目了
    let len = nums.length, cap = n;
    // 1、定义dp数组，因为要取最小值，所以不确定和不合法的都赋予最大值
    const dp = new Array(len+1).fill().map(() => new Array(cap+1).fill(Infinity))

    // 2、初始化，dp[0][i]不合法设最大值
    dp[0][0] = 0

    // 3、遍历更新状态
    for(let i=1; i<=len; i++){
        for(let j=0; j<=cap; j++){
            // 容量有限，放不下,那么此时的状态还是未选择之前的状态
            if(j < nums[i-1]){
                dp[i][j] = dp[i-1][j]
            }else{
                dp[i][j] = Math.min(dp[i-1][j],dp[i][j-nums[i-1]] + 1)
            }
        }
    }
    return dp[len][cap]
};