0-1背包之分割等和子集 && 空间优化二维数组

「0-1 背包问题」，它的特点是：「每个数只能用一次」。解决的基本思路是：物品一个一个选，容量也一点一点增加去考虑，这一点是「动态规划」的思想，特别重要。

具体做法是：画一个 len 行，target + 1 列的表格。这里 len 是物品的个数，target 是背包的容量。len 行表示一个一个物品考虑，target + 1多出来的那 1 列，表示背包容量从 0 开始考虑，也就是因为数组下标是从0开始的。所以很多时候，我们需要考虑这个容量为 0 的数值。

• 状态定义：dp[i] [j]表示从数组的 [0, i] 这个子区间内挑选一些正整数，每个数只能用一次，使得这些数的和恰好等于 j。

• 状态转移方程：很多时候，状态转移方程思考的角度是「分类讨论」，对于「0-1 背包问题」而言就是「当前考虑到的数字选与不选」。
  不选择 nums[i]，如果在 [0, i - 1] 这个子区间内已经有一部分元素，使得它们的和为 j ，那么 dp[i] [j] = true；
  选择 nums[i]，如果在 [0, i - 1] 这个子区间内就得找到一部分元素，使得它们的和为 j - nums[i]。

• j - nums[i] 作为数组的下标，一定得保证大于等于 0 ，因此 nums[i] <= j；

• 注意到一种非常特殊的情况：j 恰好等于 nums[i]，即单独 nums[j] 这个数恰好等于此时「背包的容积」 j，这也是符合题意的。

看LeetCode 416题 分割等和子集

给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

注意:

1、每个数组中的元素不会超过 100

2、数组的大小不会超过 200
示例 1:

输入: [1, 5, 11, 5]

输出: true

解释: 数组可以分割成 [1, 5, 5] 和 [11].

示例 2:

输入: [1, 2, 3, 5]

输出: false

解释: 数组不能分割成两个元素和相等的子集.

解法

本题可以看做是0-1背包问题，设所有数字和为 sum，我们的目标是选取一部分物品，使得它们的总和为 sum/2。这道题不需要考虑价值，因此只需要通过一个布尔值矩阵来表示状态转移矩阵。

dp数组：

dp[i] [j] 代表的意义是从数组下标[0,i]的范围选出若干个整数(不选也行)，是否存在一种选取方案使得选出来的数的和等于j。

边界情况：

• 如果不选任何整数，那么整数和就是0.所以对于0≤i<len，都有dp[i] [0] = true；当 j - nums[i] == 0 成立的时候，根据上面分析，就说明单独的 nums[i] 这个数就恰好能够在被分割为单独的一组，其余的数分割成为另外一组。因此，我们把初始化的 dp[i][0] 设置成为 true
• 当i = 0时，表示只有第一个整数nums[0]可以被选，因此dp[0] [nums[0]] = true

状态转移方程：

当i > 0 && j >0的情况下，有两种情况

第一种j ≥ nums[i]时，也就意味着背包的容量允许放入第i个物品的重量nums[i]

• 如果不选nums[i]，则dp[i] [j] = dp[i - 1] [j]

• 如果选了nums[i]，则dp[i] [j] = dp[i - 1] [j - nums[i]]

第二种j < nums[i],意味着第i个物品不能放进去

所以dp[i] [j] = dp[i - 1] [j]

最后得到的dp[n - 1] [target] 就是最后的答案

public class Solution {
  public boolean canPartition(int[] nums) {
		int len = nums.length;
    int sum = 0;
    for (int num : nums) {
      sum += num;
    }
    //如果是奇数，就不符合要求
    if ((sum & 1) == 1) {
			return false;
    }
    int target = sum / 2;
    // 创建二维状态数组，行：物品索引，列：容量（包括 0）
    boolean[][] dp = new boolean[len][target + 1];
    //第一列都为真
    for (int i = 0; i < n; i++) {
      dp[i][0] = true;
    }
    // 先填表格第 0 行，第 1 个数只能让容积为它自己的背包恰好装满
    if (nums[0] <= target) {
      dp[0][nums[0]] = true;
    }
    //再填后面几行
    for (int i = 0; i < len; i++) {
      for (int j = 0; j <= target; j++) {
        //将上一行的结果抄下来再修改
        dp[i][j] = dp[i - 1][j];
        if (nums[i] == j) {
          dp[i][j] = true;
          continue;
        }
        if (nums[i] < j) {
          dp[i][j] = dp[i - 1][j] || dp[i][j - nums[i]];
        }
      }
    }
    return dp[len - 1][target];  
  }
}

复杂度分析：

• 时间复杂度：O(NC) N是数组元素的个数，C是数组元素和的一半
• 空间复杂度：O(NC)

空间优化

「0-1 背包问题」常规优化：「状态数组」从二维降到一维，减少空间复杂度。

在填dp数组的时候，当前行只参考上一行的值，因此状态数组可以设置两行，使用滚动数组的技巧；

其实在滚动数组的基础上还可以优化，因为当前行总是参考它上面的一行，和左上角的某个未知的值。所以可以设置一个一维数组，从后向前填表。

从后向前」 写的过程中，一旦 nums[i] <= j 不满足，可以马上退出当前循环，因为后面的 j 的值肯定越来越小，没有必要继续做判断，直接进入外层循环的下一层。相当于也是一个剪枝，这一点是「从前向后」填表所不具备的。

public class Solution {
  public boolean canPartition(int[] nums) {
    int len = nums.length;
    int sum = 0;
    for (int num : nums) {
      sum += num;
    }
    if ((sum & 1) == 1) {
      return false;
    }
    int target = sum / 2;
    boolean[] dp = new boolean[target + 1];
    dp[0] = true;
    
    if (nums[0] <= target) {
      dp[nums[0]] = true;
    }
    for (int i = 1; i < len; i++) {
      for (int j = target; nums[i] <= j; i++) {
				if (dp[target]) {
            return true;
          }
        dp[j] = dp[j] || dp[j - nums[i]];
      }
    }
    return dp[target];
  }
}

复杂度分析：

• 时间复杂度：O(NC) N是数组元素的个数，C是数组元素和的一半
• 空间复杂度：O( C)