这是我参与2022首次更文挑战的第24天，活动详情查看：2022首次更文挑战

一和零

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的长度，该子集中 最多 有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。

 

示例 1：

输入：strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3

输出：4

解释：最多有 5 个 0 和 3 个 1 的最大子集是 {"10","0001","1","0"} ，因此答案是 4 。 其他满足题意但较小的子集包括 {"0001","1"} 和 {"10","1","0"} 。{"111001"} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。

示例 2：

输入：strs = ["10", "0", "1"], m = 1, n = 1

输出：2

解释：最大的子集是 {"0", "1"} ，所以答案是 2 。  

提示：

1 <= strs.length <= 600

1 <= strs[i].length <= 100

strs[i] 仅由 '0' 和 '1' 组成

1 <= m, n <= 100

题解

算法一：动态规划（Java）

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

dp[i][j]：最多有i个0和j个1的strs的最大子集的大小为dp[i][j]。

2 确定递推公式

dp[i][j]可以由前一个strs里的字符串推导出来，该字符串有zeroNum个0，oneNum个1。

dp[i][j]就可以是dp[i-zeroNum][j-oneNum]+1(加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背包！只不过物品的重量有了两个维度而已。

3 dp数组如何初始化

01背包的dp数组初始化为0就可以。

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

4 确定遍历顺序

01背包一定是外层for循环遍历物品，内层for循环遍历背包容量且从后向前遍历！

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        if (strs == null || strs.length == 0) {
            return 0;
        }

        int[][] dp = new int[m + 1][n + 1];
        for (int i = 0; i < strs.length; i++) {
            int[] countOneAndZero = countOneAndZero(strs[i]);
            for (int j = m; j >= 0; j--) {
                for (int k = n; k >= 0; k--) {
                    int zero = countOneAndZero[0];
                    int one = countOneAndZero[1];
                    if (j >= zero && k >= one) {
                        dp[j][k] = Math.max(dp[j][k], dp[j - zero][k - one] + 1);
                    }
                }
            }
        }
        return dp[m][n];
    }

    public int[] countOneAndZero(String str) {
        int one = 0;
        int zero = 0;
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) == '0') {
                zero++;
            } else {
                one++;
            }
        }
        return new int[]{
                zero, one
        };
    }
}

时间复杂度：O（lmn + L）

空间复杂度：O（mn）

l 是数组 strs 的长度，m 和 n 分别是 0 和 1 的容量

算法一：动态规划（Go）

思路同上

func findMaxForm(strs []string, m int, n int) int {
    dp := make([][]int, m+1)
    for i:=0;i<=m;i++{
        dp[i] = make([]int, n+1)
    }
    for _, str := range strs{
        zeroNum, oneNum := strings.Count(str, "0"), strings.Count(str, "1")
        for i:=m;i>=zeroNum;i--{
            for j:=n;j>=oneNum;j--{
                dp[i][j] = max(dp[i][j], dp[i-zeroNum][j-oneNum]+1)
            }
        }
    }
    return dp[m][n]
}

func max(a, b int) int{
    if a > b{
        return a
    }
    return b
}

时间复杂度：O（lmn + L）

空间复杂度：O（mn）

l 是数组 strs 的长度，m 和 n 分别是 0 和 1 的容量