动态规划：力扣474. 一和零（巧妙转化为01背包问题）

1、题目描述：


2、题解：
动态规划：

1、状态定义；

2、状态转移方程；

3、初始化；

4、输出；

5、思考状态压缩。

可以用递归去求，但是会存在重叠子问题，加个备忘录可以解决重复问题。
把总共的 0 和 1 的个数视为背包的容量，每一个字符串视为装进背包的物品。这道题就可以使用 0-1 背包问题的
状态定义：
dp[i][j][k] 表示输入字符串在子区间 [0, i] 能够使用 j 个 0 和 k 个 1 的字符串的最大数量。
状态转移方程：
dp[i][j][k]=dp[i−1][j−当前字符串使用0的个数][k−当前字符串使用1的个数]+1，选择当前的字符串
初始化：
为了避免分类讨论，通常多设置一行。这里可以认为，第 0 个字符串是空串。第 0 行默认初始化为 0。
Python语音代码如下：

class Solution:
    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
        #动态规划，01背包
        def CountZeroAndOne(s):
            cnt = [0] * 2
            for c in s:
                if c == '0':
                    cnt[0] += 1
                elif c == '1':
                    cnt[1] += 1
            return cnt
        len_ = len(strs)
        dp = [[[0] * (n + 1) for _ in range(m + 1)] for _ in range(len_ + 1)]
        for i in range(1,len_ + 1):
            cnt = CountZeroAndOne(strs[i-1])
            for j in range(m + 1):
                for k in range(n + 1):   
                    dp[i][j][k] = dp[i - 1][j][k]                 
                    zeros,ones = cnt[0],cnt[1]
                    if j >= zeros and k >= ones:
                        dp[i][j][k] = max(dp[i-1][j][k],dp[i-1][j-zeros][k-ones] + 1)        
        return dp[len_][m][n]

当然由于python语音自身的特点，可以调用一些方法来完成：

class Solution:
    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
        #动态规划，01背包
        len_ = len(strs)
        dp = [[[0] * (n + 1) for _ in range(m + 1)] for _ in range(len_ + 1)]
        for i in range(1,len_ + 1):
            zeros = strs[i - 1].count('0')
            ones = strs[i - 1].count('1')
            for j in range(m + 1):
                for k in range(n + 1):   
                    dp[i][j][k] = dp[i - 1][j][k]                 
                    if j >= zeros and k >= ones:
                        dp[i][j][k] = max(dp[i-1][j][k],dp[i-1][j-zeros][k-ones] + 1)        
        return dp[len_][m][n]

状态压缩：
要用一个技巧，内循环倒着进行操作：

class Solution:
    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
        #动态规划，01背包，空间优化 
        def CountZeroAndOne(s):
            cnt = [0] * 2
            for c in s:
                if c == '0':
                    cnt[0] += 1
                elif c == '1':
                    cnt[1] += 1
            return cnt
        len_ = len(strs)
        if len_ == 0:
            return 0
        dp = [[0] * (n + 1) for _ in range(m + 1)] 
        for st in strs:
            cnt = CountZeroAndOne(strs[i-1])
            for j in range(m,-1,-1):
                for k in range(n,-1,-1):
                    zeros,ones = cnt[0],cnt[1]
                    if j >= zeros and k >= ones:
                        dp[j][k] = max(dp[j][k],dp[j-zeros][k-ones] + 1)
        return dp[-1][-1]  

同样也可以写成下面这样：

class Solution:
    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
        #动态规划，01背包，空间优化 
        len_ = len(strs)
        if len_ == 0:
            return 0
        dp = [[0] * (n + 1) for _ in range(m + 1)] 
        for st in strs:
            zeros,ones = st.count('0'),st.count('1')
            for j in range(m,-1,-1):
                for k in range(n,-1,-1):
                    if j >= zeros and k >= ones:
                        dp[j][k] = max(dp[j][k],dp[j-zeros][k-ones] + 1)
        return dp[-1][-1]