动态规划09-一和零(三维背包问题/Java)

09.一与零

• 题目描述

给你一个二进制字符串数组 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 。

• 题目分析

这是一个背包问题，其中背包的容量由整数m和n表示。给定一个字符串数组strs，每个字符串strs[i]由0和1组成。我们的目标是选择一些字符串，使得它们的0和1的数量之和不超过背包的容量，并且选取的字符串数量最多。

动态规划五部曲

1. 确定dp数组（dp table）以及下标的含义
三维dp数组:dp[i][j][k]表示可选物品[0-i]时满足背包为j个0，k个1时的最大长度
2. 确定递推公式
当不装入物品i：dp[i][j][k] = dp[i - 1][j][k];
当装入物品i：dp[i][j][k] = Math.max(dp[i - 1][j][k], dp[i - 1][j - zero[i]][k - one[i]] + 1);
3. dp数组如何初始化
if (zero[0] <= j && one[0] <= k) dp[0][j][k] = 1;
4. 确定遍历顺序
5. 举例推导dp数组(打印三维数组)
public static void printArray(int[][][] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.println("第 " + (i + 1) + " 行");
            for (int j = 0; j < array[i].length; j++) {
                System.out.print("\t第 " + (j + 1) + " 列 ");
                for (int k = 0; k < array[i][j].length; k++) {
                    System.out.print(array[i][j][k] + "\t");
                }
                System.out.println();
            }
            System.out.println();
        }
    }

代码中的核心是一个三维的动态规划数组dp。其中，dp[i][j][k]表示在考虑前i个字符串，且背包容量为j个0和k个1的情况下，能够组成的最大字符串数量。

代码中使用了二重循环来遍历所有可能的背包容量和字符串选择，并根据问题的约束条件来进行状态转移。具体来说，对于每个字符串strs[i]，我们统计出其中0和1的数量zeroNum和oneNum，然后进行如下判断：

如果zeroNum <= j 且 oneNum <= k，意味着可以选择strs[i]。此时，我们可以选择将strs[i]放入背包中，也可以选择不放入。因此，我们比较不放入和放入两种情况下的最大字符串数量，取较大值更新dp[i][j][k]。
如果zeroNum > j 或者 oneNum > k，意味着strs[i]无法放入当前背包容量的约束下，因此我们不能选择该字符串，直接继承前一个状态的最大字符串数量，即dp[i][j][k] = dp[i-1][j][k]。
最终，我们需要返回dp[strs.length][m][n]，表示在考虑所有字符串的情况下，背包容量为m个0和n个1时能够组成的最大字符串数量。

• Java代码实现

public static int findMaxForm(String[] strs, int m, int n) {
        /* 统计每个字符串中的'0'和'1'的元素 */
        int[] zero = new int[strs.length];
        int[] one = new int[strs.length];
        for (int i = 0; i < strs.length; i++) {
            int zeroNum = 0, oneNum = 0;
            for (int j = 0; j < strs[i].length(); j++) {
                if (strs[i].charAt(j) == '0') zeroNum++;
                else oneNum++;
            }
            zero[i] = zeroNum;
            one[i] = oneNum;
        }
        /* 背包问题 */
        //三维dp数组:dp[i][j][k]表示可选物品[0-i]时满足背包为j个0，k个1时的最大长度
        int[][][] dp = new int[strs.length][m + 1][n + 1];
        //初始化dp数组
        //当只放入strs[0]时的情况
        for (int j = 0; j <= m; j++) {
            for (int k = 0; k <= n; k++) {
                if (zero[0] <= j && one[0] <= k) dp[0][j][k] = 1;
            }
        }

        //遍历背包
        for (int i = 1; i < strs.length; i++) {
            for (int j = 0; j <= m; j++) {
                for (int k = 0; k <= n; k++) {
                    if (zero[i] > j || one[i] > k) {
                        dp[i][j][k] = dp[i - 1][j][k];
                    } else {
                        dp[i][j][k] = Math.max(dp[i - 1][j][k], dp[i - 1][j - zero[i]][k - one[i]] + 1);
                    }
                }
            }
        }
        return dp[strs.length - 1][m][n];
    }

• 简化代码

public static 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 zeroNum = 0, oneNum = 0;
            for (int j = 0; j < strs[i - 1].length(); j++) {
                if (strs[i - 1].charAt(j) == '0') zeroNum++;
                else oneNum++;
            }

            for (int j = 0; j <= m; j++) {
                for (int k = 0; k <= n; k++) {
                    if (zeroNum <= j && oneNum <= k) {
                        dp[i][j][k] = Math.max(dp[i - 1][j][k], dp[i - 1][j - zeroNum][k - oneNum] + 1);
                    } else {
                        dp[i][j][k] = dp[i - 1][j][k];
                    }
                }
            }
        }
        return dp[strs.length][m][n];
    }