动态规划：目标和/一和零

494. 目标和

思路：
既然为target，那么就一定有 left组合 - right组合 = target。

left + right等于sum，而sum是固定的。

公式来了， left - (sum - left) = target -> left = (target + sum)/2 。

target是固定的，sum是固定的，left就可以求出来。

此时问题就是在集合nums中找出和为left的组合。

if ((target + sum) % 2 == 1) return 0; // 此时没有方案
if (abs(target) > sum) return 0; // 此时没有方案

再回归到01背包问题，为什么是01背包呢？

因为每个物品（题目中的1）只用一次！

这次和之前遇到的背包问题不一样了，之前都是求容量为j的背包，最多能装多少。

本题则是装满有几种方法。其实这就是一个组合问题了。

• 1确定dp数组以及下标的含义 dp[j] 表示：填满j（包括j）这么大容积的包，有dp[j]种方法

  其实也可以使用二维dp数组来求解本题，dp[i][j]：使用 下标为[0,
  i]的nums[i]能够凑满j（包括j）这么大容量的包，有dp[i][j]种方法。

• 2确定递推公式 有哪些来源可以推出dp[j]呢？

  不考虑nums[i]的情况下，填满容量为j - nums[i]的背包，有dp[j - nums[i]]种方法。

  那么只要搞到nums[i]的话，凑成dp[j]就有dp[j - nums[i]] 种方法。

  例如：dp[j]，j 为5，

  已经有一个1（nums[i]） 的话，有 dp[4]种方法 凑成 dp[5]。 已经有一个2（nums[i]） 的话，有 dp[3]种方法
  凑成 dp[5]。 已经有一个3（nums[i]） 的话，有 dp[2]中方法 凑成 dp[5] 已经有一个4（nums[i]） 的话，有
  dp[1]中方法 凑成 dp[5] 已经有一个5 （nums[i]）的话，有 dp[0]中方法 凑成 dp[5]
  那么凑整dp[5]有多少方法呢，也就是把 所有的 dp[j - nums[i]] 累加起来。

dp[j] += dp[j - nums[i]]

• 3 dp数组如何初始化 从递归公式可以看出，在初始化的时候dp[0]
  一定要初始化为1，因为dp[0]是在公式中一切递推结果的起源，如果dp[0]是0的话，递归结果将都是0。

  dp[0] = 1，理论上也很好解释，装满容量为0的背包，有1种方法，就是装0件物品。

  dp[j]其他下标对应的数值应该初始化为0，从递归公式也可以看出，dp[j]要保证是0的初始值，才能正确的由dp[j -nums[i]]推导出来。

• 4 确定遍历顺序 在动态规划：关于01背包问题，你该了解这些！（滚动数组） (opens new window)中，我们讲过对于01背包问题一维dp的遍历，nums放在外循环，target在内循环，且内循环倒序

5 举例推导dp数组
输入：nums: [1, 1, 1, 1, 1], target: 3

bagSize = (target + sum) / 2 = (3 + 5) / 2 = 4

class Solution:
    def findTargetSumWays(self, nums: List[int], target: int) -> int:
        sumv = sum(nums)
        # 注意边界条件为 target>sumValue or target<-sumValue or  (sumValue + target) % 2 == 1
        if abs(target) > sumv or (target + sumv) % 2 == 1: return 0
        bagsize = (target + sumv) // 2
        dp = [0] * (bagsize + 1)
        dp[0] = 1

        for i in range(len(nums)):
            for j in range(bagsize, nums[i] - 1, -1):
                dp[j] += dp[j - nums[i]]
                #print(i,nums[i], j, dp[j])
        return dp[bagsize]

474.一和零

类似于01背包，只不过背包容量多了两个维度m和n 之前是只有bagsize的维度

1. 确定dp数组（dp table）以及下标的含义 dp[i][j]：最多有i个0和j个1的strs的最大子集的大小为dp[i][j]。
2. 确定递推公式 dp[i][j] 可以由前一个str里的字符串推导出来，strs里的一个str字符串有zeroNum个0，oneNum个1。dp[i][j] 就可以是 dp[i - zeroNum][j - oneNum] + 1。

然后我们在遍历的过程中，取dp[i][j]的最大值。

所以递推公式：dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);

此时大家可以回想一下01背包的递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

对比一下就会发现，字符串的zeroNum和oneNum相当于物品的重量（weight[i]），字符串本身的个数相当于物品的价值（value[i]）。

这就是一个典型的01背包！ 只不过物品的重量有了两个维度而已。

1. dp数组如何初始化 在动态规划：关于01背包问题，你该了解这些！（滚动数组） (opens new
   window)中已经讲解了，01背包的dp数组初始化为0就可以。

   因为物品价值不会是负数，初始为0，保证递推的时候dp[i][j]不会被初始值覆盖。

2. 确定遍历顺序 在动态规划：关于01背包问题，你该了解这些！（滚动数组） (opens new
   window)中，我们讲到了01背包为什么一定是外层for循环遍历物品，内层for循环遍历背包容量且从后向前遍历！

那么本题也是，物品就是strs里的字符串，背包容量就是题目描述中的m和n。

5. 举例推导dp数组

略

 class Solution:
    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
        # dp[i][j] 表示i个0 j个1的最大子集数 m行n列
        dp = [[0] * (n + 1) for _ in range(m + 1)]
        
          
        for str in strs:
            # 遍历每个字符串（物品） 并计算每个str的0个数 1个数
            zeronum = str.count('0')
            onenum = str.count('1')

            # 遍历（背包容量）m和n两个维度
            for i in range(m, zeronum - 1, -1):
                for j in range(n, onenum - 1, -1):
                    # 类比dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
                    # 如果选当前字符串 还剩下i - zeronum 个1 ，j - onenum 个0 ，子集数加1
                    dp[i][j] = max(dp[i][j], dp[i - zeronum][j - onenum] + 1)

        return dp[-1][-1]