《LeetCode之每日一题》：53.一和零

题目链接： 一和零

有关题目

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

提示：

1 <= strs.length <= 600
1 <= strs[i].length <= 100
strs[i] 仅由 '0' 和 '1' 组成
1 <= m, n <= 100

题解

法一：动态规划

思路：
上面说明了dp的含义
dp的初始值
下面的代码中我们说明一下转移方程为

参考官方题解

class Solution {
public:
    vector<int> getZerosOnes(string& str)//计算出0和1的个数
    {
        int len = str.length();
        vector<int> zerosOnes(2);
        for (int i = 0; i < len; i++)
        {
            ++zerosOnes[str[i] - '0'];
        }
        return zerosOnes;
    }
    int findMaxForm(vector<string>& strs, int m, int n) {
       int length = strs.size();
        vector<vector<vector<int>>> dp(length + 1, vector<vector<int>>(m + 1, vector<int>(n + 1)));
        for (int i = 1; i <= length; i++)
        {
            vector<int>&& zerosOnes = getZerosOnes(strs[i - 1]);//两个&是右值引用，可以避免重复的拷贝，一个&是引用，报错是因为由函数返回值返回的容器非法访问
            int zeros = zerosOnes[0],ones = zerosOnes[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] = max(dp[i][j][k],dp[i - 1][j - zeros][k - ones] + 1);//实际上max中的dp[i][j][k]就是dp[i - 1][j][k]
//当我们满足条件时，我们要么不选-->dp[i - 1][j][k]
//要么我们选择-->dp[i - 1][j - zeros][k - ones] + 1,对应的我们dp值加1


                }
            }
        }
        return dp[length][m][n];//我们要拿到的值其实就是直到最后一个字符串时我们使用完m和n最大的子集的元素个数
    }
};

法二：滚动数组

思路：
根据「状态转移」可知，更新某个物品的状态时，只依赖于上一个物品的状态。

因此，可以使用「滚动数组」的方式进行空间优化。

class Solution {
public:
vector<int> getZerosOnes(string& str)//计算出0和1的个数
    {
        int len = str.length();
        vector<int> zerosOnes(2);
        for (int i = 0; i < len; i++)
        {
            ++zerosOnes[str[i] - '0'];
        }
        return zerosOnes;
    }
    int findMaxForm(vector<string>& strs, int m, int n) {
        int length = strs.size();
        vector<vector<vector<int>>> dp(2, vector<vector<int>>(m + 1, vector<int>(n + 1))); // 「物品维度」修改为 2 
        for (int i = 1; i <= length; i++)
        {
            
            vector<int>&& zerosOnes = getZerosOnes(strs[i - 1]);
            int zeros = zerosOnes[0], ones = zerosOnes[1];
            
            for (int j = 0; j <= m; j++) 
            {
                for (int k = 0; k <= n; k++)
                {
                    dp[i & 1][j][k] = dp[(i - 1) & 1][j][k];
                    // 不选择i
                    // 将 i -1 修改为 (i-1)&1
                    if (j >= zeros && k >= ones)
                        dp[i & 1][j][k] = max(dp[i & 1][j][k],dp[(i - 1) & 1][j - zeros][k - ones] + 1);
                }
            }
        }
        return dp[length & 1][m][n];
    }
};

法三：一维空间优化

class Solution {
public:
vector<int> getZerosOnes(string& str)//计算出0和1的个数
    {
        int len = str.length();
        vector<int> zerosOnes(2);
        for (int i = 0; i < len; i++)
        {
            ++zerosOnes[str[i] - '0'];
        }
        return zerosOnes;
    }
    int findMaxForm(vector<string>& strs, int m, int n) {
        int length = strs.size();
        vector<vector<int>> dp(m + 1, vector<int>(n + 1));
        for (int i = 0; i < length; i++)
        {
            
            vector<int>&& zerosOnes = getZerosOnes(strs[i]);
            int zeros = zerosOnes[0], ones = zerosOnes[1];
            //保证得到是dp[i - 1][][]中的值，所以我们倒叙输入
            for (int j = m; j >= zeros; j--)//注意j的条件，不满足j >= zeros我们直接连循环都不要进去了，直接保留原值就好了 
            {
                for (int k = n; k >= ones; k--)
                {
                    dp[j][k] = max(dp[j][k], dp[j - zeros][k - ones] + 1);
                }
            }
        }
        return dp[m][n];
    }
};