java一和零（力扣Leetcode474）

一和零

力扣原题

给定一个二进制字符串数组 strs 和两个整数 m 和 n，请你找出并返回 strs 的最大子集的长度，该子集中最多有 m 个 0 和 n 个 1。

示例 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 。

二维数组解法

分析

这是一个典型的二维动态规划问题。我们可以将每个字符串看作是一种物品，其中 0 的个数和 1 的个数就是物品的体积和价值。题目要求最大子集的长度，相当于要求装入背包的物品数量的最大值，而背包的容量由给定的 m 和 n 决定。

状态定义

我们定义一个二维的动态规划数组 dp，其中 dp[i][j] 表示在前 i 个字符串中，能够拥有不超过 m 个 0 和不超过 n 个 1 的最大子集的长度。

状态转移方程 (二维背包问题，实质上还是01背包，因为“物品”只能选一次）

在状态转移方程中，我们需要考虑当前字符串是否放入背包中的两种情况：

• 如果不放入当前字符串，则 dp[i][j] = dp[i-1][j]；
• 如果放入当前字符串，则 dp[i][j] = dp[i-1][j-当前字符串中0的个数][j-当前字符串中1的个数] + 1。

综合以上两种情况，状态转移方程为：

dp[i][j] = max(dp[i-1][j], dp[i-1][j-当前字符串中0的个数][j-当前字符串中1的个数] + 1)

初始化

我们需要对动态规划数组进行初始化，当没有字符串时或背包容量为0时。

Java解题

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][] dp = new int[m + 1][n + 1]; // 初始化动态规划数组
        for (String str : strs) { // 遍历物品，每个物品（每个字符串）只能使用一次，相当于01背包
            int zeros = 0, ones = 0; // 每次循环都初始化 统计当前字符串中0和1的个数
            for (char c : str.toCharArray()) {
                if (c == '0') zeros++;//计算“0物品”的重量
                else ones++;//计算“1物品”的重量
            }
            //遍历背包，相当于背包有两个维度
            for (int i = m; i >= zeros; i--) { // 更新动态规划数组
                for (int j = n; j >= ones; j--) {
                    dp[i][j] = Math.max(dp[i][j], dp[i - zeros][j - ones] + 1);
                }
            }
        }
        return dp[m][n]; // 返回最大子集的长度
    }
}

总结

通过以上步骤，我们可以解决这个问题。首先将每个字符串看作是一种物品，然后根据动态规划的思想进行状态转移，最终返回最大子集的长度。

三维数组解法

分析

这是一个典型的动态规划问题。我们需要在满足条件的情况下找出最大子集的长度。可以将问题转化为01背包问题，其中背包的容量为 (m, n)，物品的重量和价值分别为字符串中 0 和 1 的数量。

状态定义

定义一个三维动态规划数组 dp，其中 dp[i][j][k] 表示在前 i 个字符串中，最多有 j 个 0 和 k 个 1 的最大子集的长度。

状态转移方程

对于每一个字符串 strs[i]，我们有两种选择：选择或者不选择。因此状态转移方程为：

dp[i][j][k] = max(dp[i - 1][j][k], dp[i - 1][j - zero][k - one] + 1)

其中 zero 和 one 分别表示字符串 strs[i] 中 0 和 1 的数量。

初始化

我们需要对动态规划数组进行初始化。初始时，前 0 个字符串中最多有 0 个 0 和 0 个 1 的最大子集的长度为 0。

Java解题

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][][] dp = new int[strs.length + 1][m + 1][n + 1];
        for (int i = 1; i <= strs.length; i++) {
            int[] count = countZeroesOnes(strs[i - 1]);
            int zeros = count[0], ones = count[1];
            for (int j = 0; j <= m; j++) {
                for (int k = 0; k <= n; k++) {
                    dp[i][j][k] = dp[i - 1][j][k];
                    if (j >= zeros && k >= ones) {
                        dp[i][j][k] = Math.max(dp[i][j][k], dp[i - 1][j - zeros][k - ones] + 1);
                    }
                }
            }
        }
        return dp[strs.length][m][n];
    }
    
    private int[] countZeroesOnes(String str) {
        int[] count = new int[2];
        for (char c : str.toCharArray()) {
            count[c - '0']++;
        }
        return count;
    }
}

总结

通过动态规划的思想，我们可以解决这个问题。首先计算每个字符串中 0 和 1 的数量，然后根据状态转移方程进行状态转移，最终返回最大子集的长度。