「这是我参与11月更文挑战的第18天，活动详情查看：2021最后一次更文挑战」

879 盈利计划

题目描述

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

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

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

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

示例 1：

输入：n = 5, minProfit = 3, group = [2,2], profit = [2,3]
输出：2
解释：至少产生 3 的利润，该集团可以完成工作 0 和工作 1 ，或仅完成工作 1 。
总的来说，有两种计划。

示例 2：

输入：n = 10, minProfit = 5, group = [2,3,5], profit = [6,7,8]
输出：7
解释：至少产生 5 的利润，只要完成其中一种工作就行，所以该集团可以完成任何工作。
有 7 种可能的计划：(0)，(1)，(2)，(0,1)，(0,2)，(1,2)，以及 (0,1,2) 。

方法：动态规划

解题思路

与常规背包问题只有容量限制不同的是，该题除了容量限制还有最低利润限制

设dp[i][j][k]表示从前i项工作中挑选若干项，总人数为j人，利润最少为k时的总方案数

初始化dp[0][0][0] = 1

计算dp[i][j][k]：

• 对于第i项工作（从1开始计数），members = group[i - 1]，pro = profit[i - 1]

• 若j < members，即仅这一项工作即超出人数限制，故不选该项工作，于是

​ dp[i][j][k] = dp[i - 1][j][k]，即方案数取决于前i - 1项工作

• 若j >= members，即可选该项工作

  • 若不选该项工作，满足条件的方案数：dp[i - 1][j][k]
  • 若选该项工作，满足条件的方案数：dp[i - 1][j - members][Math.max(0, k - pro)]
  • 总方案数dp[i][j][k] = dp[i - 1][k] + dp[i - 1][j - members][Math.max(0, k - pro)]

  注：上述取Math.max(0, k - pro)的原因是因为我们求的是利润最少为k时的方案数，倘若仅第i项工作的利润已经达到k，那么对于前i - 1项工作来说，只要满足人数限制即可，一直递推，满足条件的均会推到dp[0][0][0] = 1

优化

考虑到dp每一行的计算只与上一行有关，所以不必使用三维数组，可以使用滚动数组，去掉dp的第一个维度

内存循环应从j、k最大值开始倒序遍历，保证转移来的是dp[i - 1][][]的元素

且数组含义也可改变来进行优化

设dp[j][k]表示人数最多为j时，利润最少为k的方案数

那么最终结果为dp[n][minProfit]

转移方程不变，初始化需要改变

​ dp[j][0] = 1，表示利润为0时总有一种方案能满足要求

代码

/**
 * @param {number} n
 * @param {number} minProfit
 * @param {number[]} group
 * @param {number[]} profit
 * @return {number}
 */
var profitableSchemes = function(n, minProfit, group, profit) {
    const MOD = 1000000007
    const len = group.length
    const dp = new Array(n + 1).fill(0).map(() => new Array(minProfit + 1).fill(0))
    for (let i = 0; i <= n ; i++) {
        dp[i][0] = 1
    }
    // dp[0][0] = 1
    for (let i = 0; i < len; i++) {
        let members = group[i]
        let pro = profit[i]
        for (let j = n; j >= members; j--) {
            for (let k = minProfit; k >= 0; k--) {
                dp[j][k] = (dp[j][k] + dp[j - members][Math.max(0, k - pro)]) % MOD
            }
        }
    }
    // let res = 0
    // for (let i = 0; i <= n; i++) {
    //     res = (res + dp[i][minProfit]) % MOD
    // }
    // return res
    return dp[n][minProfit]
};

算法复杂度分析

1. 时间复杂度：O(len * n * minProfit)
2. 空间复杂度：O(n * minProfit)