代码随想录day38 动态规划（4）

1049. 最后一块石头的重量 II - 力扣（LeetCode） 

难点在于将此问题转为0-1背包问题。思路是将石头分为重量尽可能接近的两堆，两堆之间对碰，到最后剩下的重量会最小。解法与分割等和子集类似。易错点是遍历target时从后往前。

class Solution:
    def lastStoneWeightII(self, stones: List[int]) -> int:
        if len(stones) == 1:
            return stones[0]
        target = sum(stones) // 2

        dp = [0 for _ in range(target+1)]
        
        for i in range(len(stones)):
            for j in range(target, 0, -1):
                if stones[i] <= j:
                    dp[j] = max(dp[j], dp[j-stones[i]] + stones[i])
        
        sum1 = dp[-1]
        sum2 = sum(stones) - sum1
        return abs(sum1 - sum2)

 

494. 目标和 - 力扣（LeetCode）

    相当于将nums分为两部分，第一部分的数取正，第二部分数取负，使得加上正负号后的和为target。易得第一部分的数的和为possum = (sum(nums)  + target) // 2。

    当possum无法通过整除得到、或possum超出可能的范围，无法得到题意的组合，返回0。

    接下来在nums中找到和为possum的数的组合数。dp[j]表示第0个数到当前数范围内取数，能得到和==j的组合数。

    dp[0]初始为0，表示只有空集这一种方案满足和==0。

    正序遍历nums、倒叙遍历dp，对当前数nums[i]，若它大于j，只能不选择它，此时dp[j]不需改变（沿用上一个数，即“上一行”的值）；若它不大于j，可以选择不让nums[i]加入，对应dp[j]种组合数，也可以选择让nums[i]加入，对应dp[j-nums[i]]种组合数，新的dp[j]是这两种选择对应的组合数之和。

class Solution:
    def findTargetSumWays(self, nums: List[int], target: int) -> int:
        tmp = (sum(nums) + target)
        if tmp % 2:
            return 0
        possum = tmp // 2
        if possum > sum(nums) or possum < 0:
            return 0

        #base
        dp = [0 for _ in range(possum+1)]
        dp[0] = 1

        for i in range(len(nums)):
            for j in range(possum, -1, -1):
                if j >= nums[i]:
                    dp[j] += dp[j-nums[i]]
        
        return dp[-1]

474. 一和零 - 力扣（LeetCode）

class Solution:
    def cnt(self, str):
        n0 = 0
        n1 = 0
        for c in str:
            if c == '0':
                n0 += 1
            if c == '1':
                n1 += 1
        return n0, n1

    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
        dp = [[0 for _ in range(n+1)] for _ in range(m+1)]
        
        for s in strs:
            n0, n1 = self.cnt(s)
            for i in range(m, n0-1, -1):
                for j in range(n, n1-1, -1):
                    dp[i][j] = max(dp[i][j], dp[i-n0][j-n1] + 1)

        return dp[-1][-1]

写成这样也可以： 

class Solution:
    def cnt(self, str):
        n0 = 0
        n1 = 0
        for c in str:
            if c == '0':
                n0 += 1
            if c == '1':
                n1 += 1
        return n0, n1

    def findMaxForm(self, strs, m: int, n: int) -> int:
        dp = [[0 for _ in range(n+1)] for _ in range(m+1)]
        
        for s in strs:
            for i in range(m, -1, -1):
                for j in range(n, -1, -1):
                    n0, n1 = self.cnt(s)
                    if n0 <= i and n1 <= j:
                        dp[i][j] = max(dp[i][j], dp[i-n0][j-n1] + 1)

        return dp[-1][-1]

注意遍历strs时，对每个字符串i和j的范围不可以是range(m, 0, -1)，因为这是二维的背包，仅凭i==0或j==0不能判定只有空串满足条件，也可以是只有1或只有0的字符串，所以dp[0][x]或dp[x][0]不一定为0；只有dp[0][0]一定为0.