一和零
力扣原题
给定一个二进制字符串数组 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 的数量,然后根据状态转移方程进行状态转移,最终返回最大子集的长度。