每日一题 LeetCode 474. 一和零 java题解

题目

https://leetcode-cn.com/problems/ones-and-zeroes/

01背包问题，m和n两种维度

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][] dp=new int[m+1][n+1];
        dp[0][0]=0;
        for(String str:strs){//外层循环遍历物品
            int zero=0,one=0;
            for(char c:str.toCharArray()){
                if(c=='0') zero++;
                if(c=='1') one++;
            }
            for(int i=m;i>=zero;i--){
                for(int j=n;j>=one;j--){
                    dp[i][j]=Math.max(dp[i][j],dp[i-zero][j-one]+1);
                    //dp[i][j]:直到上一个字符串，在容量为i,j时，创造的最大子集长度。也就是不加入当前字符串。
                    //dp[i-zero][j-one]：直到上一个字符串，在容量为i-zero,j-one时的结果。然后加入当前字符串。
                }
            }
        }
        return dp[m][n];//容量为m,n时，子集中的最大个数
    }
}
/*
背包有两个维度：0的数量和1的数量，作为容量
对每个物品，也就是每个字符串而言，都有各自的0、1数量
背包的value：子集中，字符串的个数
 */

1.未优化的动态规划

思路

动态规划。
用dp[i][j][k]表示前i个字符串中 j个0、k个1的最大子集大小 。下标均从1开始计数。
当i=0时，没有字符串，所以dp[i][j][k]=0。

转移方程
这个字符串的0和1个数分别为zeros,ones.
1.j>=zeros&&k>=ones
(1)向子集中加入这个字符串
dp[i][j][k]=dp[i-1][j-zeros][k-ones]+1
(2)不向子集中加入
dp[i][j][k]=dp[i-1][j][k]
综上，dp[i][j][k]=min(dp[i-1][j-zeros][k-ones]+1,dp[i][j][k]=dp[i-1][j][k]);
2.else
dp[i][j][k]=dp[i-1][j][k]

代码

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int len=strs.length;
        if(len==0)
            return 0;
        int[][][] dp=new int[len+1][m+1][n+1];
        /*
        for(int j=0;j<=m;j++){
            for(int k=0;k<=n;k++){
                dp[0][j][k]=0;
            }
        }
        */
        
        for(int i=1;i<=len;i++){
            int zeros=count(strs[i-1]);
            int ones=strs[i-1].length()-zeros;
            
            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-1][j-zeros][k-ones]+1,dp[i][j][k]);
                    }
                }
            }
        }
        return dp[len][m][n];
    }
    //统计0的个数
    public int count(String s){
        int count=0;
        for(char c:s.toCharArray()){
            if(c=='0'){
                count++;
            }
        }
        return count;
    }
}

复杂度

时间复杂度：O(lmn+L)，其中 l 是数组 strs 的长度，m 和 n 分别是 0 和 1 的容量，L 是数组 strs 中的所有字符串的长度之和。
空间复杂度 O(lmn)

2.空间优化

复杂度

空间复杂度：O(mn)，其中 m 和 n 分别是 0 和 1 的容量。使用空间优化的实现，需要创建 m+1 行 n+1 列的二维数组dp。

代码

由于dp[i][][] 的每个元素值的计算只和dp[i−1][][] 的元素值有关，因此可以使用滚动数组的方式，去掉 dp 的第一个维度，将空间复杂度优化到 O(mn)。
实现时，内层循环需采用倒序遍历的方式，这种方式保证转移来的是dp[i−1][][] 中的元素值。

    public int findMaxForm(String[] strs, int m, int n) {
        int[][] dp = new int[m + 1][n + 1];
        int length = strs.length;
        for (int i = 0; i < length; i++) {
            int[] zerosOnes = getZerosOnes(strs[i]);
            int zeros = zerosOnes[0], ones = zerosOnes[1];
            for (int j = m; j >= zeros; j--) {
                for (int k = n; k >= ones; k--) {
                    dp[j][k] = Math.max(dp[j][k], dp[j - zeros][k - ones] + 1);
                }
            }
        }
        return dp[m][n];
    }

难死谁了

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][] str=new int[strs.length+1][2];
        //[0]0的个数，[1]1的个数.统计每个字符串的01个数
        for(int i=1;i<=strs.length;i++){
            char[] cs=strs[i-1].toCharArray();
            for(char c:cs){
                if(c=='0'){
                    str[i][0]++;
                }
                else{
                    str[i][1]++;
                }
            }
        }
        int[][][] dp=new int[strs.length+1][m+1][n+1];//dp代表最大子集数量
        //i：前i个字符串；j：0最大容量；k：1最大容量
        //注意i的含义！！预留了0，指没有物品。

        //初始状态？？？
        for (int j = 0; j <= m; j++) {
            for (int k = 0; k <= n; k++) {
                dp[0][j][k] = 0;
            }
        }

        //先遍历物品
        for(int i=1;i<=strs.length;i++){
            //遍历01数量，应该如何遍历？？？
            for(int j=0;j<=m;j++){//注意起点～
                for(int k=0;k<=n;k++){//遍历0和1的数量
                    dp[i][j][k]=dp[i-1][j][k];
                    if(j>=str[i][0]&&k>=str[i][1])
                        dp[i][j][k]=Math.max(dp[i-1][j][k],dp[i-1][j-str[i][0]][k-str[i][1]]+1);
                }
            }
        }
        return dp[strs.length][m][n];
    }
}
/**
每个字符串都是一个物品，物品有两个维度：0的个数、1的个数
 */