Leetcode 474. 一和零

474. 一和零

思路

典型的背包不超过容积的变种问题，相比于普通背包多了一维。
类比地，这样定义状态$f[i,j,k]$: 从前i个字符串中选，0的总数不超过j，1的总数不超过k的选取集合数的最大值。
由此可以得到状态转移方程：
$$f[i,j,k]=Math.max(f[i-1,j,k],f[i-1,j-nums[i][0],k-nums[i][1]])$$
其中， $nums[i][0(1)]$表示第$i$个字符串中0(1)的个数。

• 解释：对于每一个$f[i]$，有两种选法：

1. 从前$i$个中选，不选第$i$个，那么就直接等于$f[i-1,j,k]$；
2. 从前$i$个中选，选第$i$个，那么就转移到$f[i-1,j-nums[i][0],k-nums[i][1]]$，容量缩小相应的0和1的数量；

• 初始化：全部不需要初始化，默认值都为0。
  因为$f[0,x,x]$表示从前0个中选，因此肯定选不出来，为0，并且是求最大值。

代码

三维版本

先初始化nums数组，统计每个字符串0和1的个数，之后三重循环依次求解。

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int len = strs.length;
        int[][] nums = new int[len + 1][2];
        for(int i = 0; i < len; i ++)
            for(char c : strs[i].toCharArray())
                nums[i + 1][c - '0']++;
        int[][][] f = new int[len + 1][m + 1][n + 1];
        for(int i = 1; i <= len; i++){
            for(int j = 0; j <= m; j++){
                for(int k = 0; k <= n; k++){
                    if(j >= nums[i][0] && k >= nums[i][1])
                        f[i][j][k] = Math.max(f[i - 1][j][k], f[i - 1][j - nums[i][0]][k - nums[i][1]] + 1);
                    else f[i][j][k] = f[i - 1][j][k];
                }
            }
        }
        return f[len][m][n];
    }
}

二维版本

由于每一层$i$循环，只会用到$i-1$，因此可以去掉第一维，并且$j,k$需要倒着循环，避免先修改的数据被后面的用到。

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int len = strs.length;
        int[][] nums = new int[len + 1][2];
        for(int i = 0; i < len; i ++)
            for(char c : strs[i].toCharArray())
                nums[i + 1][c - '0']++;
        int[][] f = new int[m + 1][n + 1];
        for(int i = 1; i <= len; i++){
            int[] num = nums[i];
            for(int j = m; j >= num[0]; j--){
                for(int k = n; k >= num[1]; k--){
                    f[j][k] = Math.max(f[j][k], f[j - nums[i][0]][k - nums[i][1]] + 1);
                }
            }
        }
        return f[m][n];
    }
}

合并循环

由于对0和1的统计只有当前$i$轮循环用的到，因此可以在合并循环。

class Solution {
    /*
        f[i, j, k] = Math.max(f[i - 1, j, k], f[i - 1, j - strs[i][0], k - stes[i][1]])
    */
    public int findMaxForm(String[] strs, int m, int n) {
        int len = strs.length;
        int[][] f = new int[m + 1][n + 1];
        for(int i = 1; i <= len; i++){
            int num0 = 0, num1 = 0;
            for(char c : strs[i - 1].toCharArray())
                if(c == '0') num0 ++;
                else num1++;
            for(int j = m; j >= num0; j--){
                for(int k = n; k >= num1; k--){
                    f[j][k] = Math.max(f[j][k], f[j - num0][k - num1] + 1);
                }
            }
        }
        return f[m][n];
    }
}

可以看到优化效果很明显。

复杂度分析

时间复杂度

三重循环，$O(kmn)$。

空间复杂度

优化前后为，$O(kmn)$ -> $O(mn)$。