1 一和零

1.1 题目链接

1.2 题目描述

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

1.3 解法（动态规划）

算法思路：

先将问题转化成我们熟悉的题型。

i. 在⼀些物品中「挑选」⼀些出来，然后在满⾜某个「限定条件」下，解决⼀些问题，⼤概率是背包模型；
ii. 由于每⼀个物品都只有 1 个，因此是⼀个「01 背包问题」。
但是，我们发现这⼀道题⾥⾯有「两个限制条件」。因此是⼀个「⼆维费⽤的 01 背包问题」。那么我们定义状态表⽰的时候，来⼀个三维 dp 表，把第⼆个限制条件加上即可。

状态表⽰：

dp[i][j][k] 表⽰：从前 i 个字符串中挑选，字符 0 的个数不超过 j ，字符 1 的个数不超过 k ，所有的选法中，最⼤的⻓度。
状态转移⽅程：

线性 dp 状态转移⽅程分析⽅式，⼀般都是「根据最后⼀步」的状况，来分情况讨论。为了⽅便叙述，我们记第 i 个字符中，字符 0 的个数为 a ，字符 1 的个数为 b ：
- i. 不选第 i 个字符串：相当于就是去前 i - 1 个字符串中挑选，并且字符 0 的个数不超过 j ，字符 1 的个数不超过 k 。此时的最⼤⻓度为 dp[i][j][k] = dp[i - 1][j][k] ；
- ii. 选择第 i 个字符串：那么接下来我仅需在前 i - 1 个字符串⾥⾯，挑选出来字符 0 的个数不超过 j - a ，字符 1 的个数不超过 k - b 的最⻓⻓度，然后在这个⻓度后⾯加上字符串 i 即可。。此时 dp[i][j][k] = dp[i - 1][j - a][k - b] + 1 。
但是这种状态不⼀定存在，因此需要特判⼀下。
综上，状态转移⽅程为：
- dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j - a][k - b] + 1) 。

初始化：

当没有字符串的时候，没有⻓度，因此初始化为 0 即可。
填表顺序：

保证第⼀维的循环「从⼩到⼤」即可。
返回值：
- 根据「状态表⽰」，我们返回 dp[len][m][n] 。
- 其中 len 表⽰字符串数组的⻓度。
空间优化：

所有的「背包问题」，都可以进⾏空间上的优化。
对于「⼆维费⽤的 01 背包」类型的，我们的优化策略是：
- i. 删掉第⼀维；
- ii. 修改第⼆层以及第三层循环的遍历顺序即可。

1.4 C++算法代码：

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        int len = strs.size();
        vector<vector<vector<int>>> dp(len + 1,vector<vector<int>>(m + 1, vector<int>(n + 1)));
        for(int i = 1; i <= len; i++)
        {
            // 统计一下字符串中 0 1 的个数
            int a = 0, b = 0;
            for(auto ch : strs[i - 1])
                if(ch == '0') a++;
                else b++;
            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 >= a && k >= b)
                        dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j - a][k - b] + 1);
                }
            }
        }
        return dp[len][m][n];
    }
};

空间优化后的算法代码：

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        int len = strs.size();
        vector<vector<int>> dp (m + 1, vector<int>(n + 1));
        for(int i = 1; i <= len; i++)
        {
            // 统计一下字符串中 0 1 的个数
            int a = 0, b = 0;
            for(auto ch : strs[i - 1])
                if(ch == '0') a++;
                else b++;
            for(int j = m; j >= a; j--)
                for(int k = n; k >= b; k--)
                        dp[j][k] = max(dp[j][k], dp[j - a][k - b] + 1);
        }
        return dp[m][n];
    }
};

2 盈利计划

2.1 题目链接

879. 盈利计划

2.2 题目描述

集团里有 n 名员工，他们可以完成各种各样的工作创造利润。

第 i 种工作会产生 profit[i] 的利润，它要求 group[i] 名成员共同参与。如果成员参与了其中一项工作，就不能参与另一项工作。

工作的任何至少产生 minProfit 利润的子集称为 盈利计划 。并且工作的成员总数最多为 n 。

有多少种计划可以选择？因为答案很大，所以 返回结果模 10^9 + 7 的值。