20210609 每日一题 盈利计划

题目

题目链接

代码

class Solution {
public:
    int profitableSchemes(int G, int P, vector<int>& group, vector<int>& profit) {

    }
};

方法一：三维动态规划

分析

该题目是一道典型的多维背包问题，设定三维数组 $dp[i][j][k]$ 表示在前 $i$ 个工作中，使用 $j$ 个工人，工作获利至少为 $k$ 的盈利计划的总数目。对于第 $i$ 个工作有选和不选两种情况：

• 如果 $j\ge group[i]$ 时，当前小组人数为 $group[i]$，工作获利为 $profit[i]$，则有工作获利至少为 $k$ 的盈利计划的总数目为前 $i-1$ 个工作中，使用 $j$ 个工人，工作获利至少为 $k$ 的盈利计划的总数目加上在前 $i-1$ 个工作中，使用 $j-group[i]$ 个工人，工作获利至少为 $k-profit[i]$ 的盈利计划的总数目，值得注意的是工作获利不可能低于 $0$，因此盈利计划的总数目为：$dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-group[i]][\max (0,k-profit[i])]$，即
• 如果 $j<group[i]$ 时，则不能选 $group[i]$，则盈利计划的总数目为： $dp[i][j][k]=dp[i-1][j][k]$。

综上所述 $dp[i][j][k]$ 的状态转移方程可表示为：
$$dp[i][j][k]=\{\begin{array}{ll}dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-group[i]][\max (0,k-profit[i])& ifj\ge group[i]\\ dp[i-1][j][k]& ifj<group[i]\end{array}$$ 问题答案为：
$$\sum _{i=0}^n\text{dp}[\text{len}][i][\text{minProfit}]$$

代码

class Solution {
public:
    int profitableSchemes(int n, int minProfit, vector<int>& group, vector<int>& profit) {
        int len = group.size();
        vector<vector<vector<int>>> dp (len + 1, vector<vector<int>>(n + 1, vector<int>(minProfit + 1)));
        dp[0][0][0] = 1;
        for (int i = 1; i <= len; ++i) {
            for (int j = 0; j <= n; ++j) {
                for (int k = 0; k <= minProfit; ++k) {
                    if (j >= group[i - 1]) {
                        dp[i][j][k] = (dp[i - 1][j][k] + dp[i - 1][j - group[i - 1]][max(0, k - profit[i - 1])]) % ((int)1e9 + 7);
                    } else {
                        dp[i][j][k] = dp[i - 1][j][k];
                    }
                }
            }
        }
        int sum = 0;
        for (int j = 0; j <= n; j++) {
            sum = (sum + dp[len][j][minProfit]) % ((int)1e9 + 7);
        }
        return sum;
    }
};

复杂度分析

• 时间复杂度：$O(len\times n\times minProfit)$，其中 $len $ 是数组长度，$n$ 是可使用员工数，$minProfit$ 是最小利润。
• 空间复杂度：$O(len\times n\times minProfit)$，其中 $len$ 是数组长度，$n$ 是可使用员工数，$minProfit$ 是最小利润，实现动态规划需要创建 $len\times n\times minProfit$ 的三维数组 $dp$。

方法二：二维动态规划

分析

根据方法一的状态转移方程可知，更新 $dp[i][][]$ 的每个元素值时，只依赖于 $dp[i-1][][]$ 的元素值。因此，可以使用一维滚动数组 $dp[j][k]$ 来替代二维数组 $dp[i][j]$ 对方法三进行空间上的优化。$dp[j][k]$ 的状态转移方程可表示为：
$$dp[j][k]=dp[j][k]+dp[j-group[i]][\max (0,k-profit[i]$$ 问题答案为：$$\sum _{i=0}^{n}dp[i][minProfit]$$

要点

根据方法一的状态转移方程，实现时内层循环需采用倒序遍历的方式更新元素值。

代码

class Solution {
public:
    int profitableSchemes(int n, int minProfit, vector<int>& group, vector<int>& profit) {
        const int MOD = 1e9 + 7;
        vector<vector<int>> dp (n + 1, vector<int>(minProfit + 1));
        dp[0][0] = 1;
        int len = group.size();
        for(int i = 0; i < len; ++i) {
            for(int j = n; j >= group[i]; --j) {
                for(int k = minProfit; k >= 0; --k) {
                    dp[j][k] = (dp[j][k] + dp[j - group[i]][max(0, k - profit[i])]) % MOD;
                }
            }
        }
        int sum = 0;
        for (int j = 0; j <= n; j++) {
            sum = (sum + dp[j][minProfit]) % MOD;
        }
        return sum;
    }
};

复杂度分析

• 时间复杂度：$O(len\times n\times minProfit)$，其中 $len $ 是数组长度，$n$ 是可使用员工数，$minProfit$ 是最小利润。
• 空间复杂度：$O(n\times minProfit)$，其中 $n$ 是可使用员工数，$minProfit$ 是最小利润，实现动态规划需要创建 $n\times minProfit$ 的二维数组 $dp$。

方法三：转换动态规划

分析

题目要求
最多使用有 $n$ 名员工且工作的任何至少产生 $minProfit$ 利润，因此可以表示为 $g\le n$，$p\ge minProfit$。$g$为实际所用员工数，$p$为实际盈利。根据容斥原理可以变化为：
$$N(g\le n)=N(g\le n,p\ge minProfit)+N(g\le n,p<minProfit)$$ $$N(g\le n,p\ge minProfit)=N(g\le n)-N(g\le n,p<minProfit)$$

代码

class Solution {
public:
    int profitableSchemes(int n, int minProfit, vector<int>& group, vector<int>& profit) {
        const int MOD = 1e9 + 7;
        int len = group.size();

        vector<vector<int>> dpTwoD(len + 1, vector<int>(n + 1, 0));
        dpTwoD[0][0] = 1;
        for(int i = 1; i <= len; ++i) {
            for(int j = 0; j <= n; ++j) {
                if(j >= group[i - 1]) {
                    dpTwoD[i][j] = (dpTwoD[i - 1][j] + dpTwoD[i - 1][j - group[i - 1]]) % MOD;
                } else {
                    dpTwoD[i][j] = dpTwoD[i - 1][j];
                }
            }
        }
        
        vector<vector<vector<int>>> dpThreeD (len + 1, vector<vector<int>>(n + 1, vector<int>(minProfit, 0)));
        if(minProfit > 0) dpThreeD[0][0][0] = 1;
        for(int i = 1; i <= len; ++i) {
            for(int j = 0; j <= n; ++j) {
                for(int k = 0; k < minProfit; ++k) {
                    if(j >= group[i - 1] && k >= profit[i - 1]) {
                        dpThreeD[i][j][k] = (dpThreeD[i - 1][j][k] + dpThreeD[i - 1][j - group[i - 1]][k - profit[i - 1]]) % MOD;
                    } else {
                        dpThreeD[i][j][k] = dpThreeD[i - 1][j][k];
                    }
                }
            }             
        }
        
        int sum = 0;
        for(int j = 0; j <= n; j++) {
            sum = (sum + dpTwoD[len][j]) % MOD;
            for(int k = 0; k < minProfit; k++) {
                sum = (sum - dpThreeD[len][j][k]) % MOD;
            }   
        }

        return (sum + MOD) % MOD;
    }
};

复杂度分析

• 时间复杂度：$O(len\times n\times minProfit)$，其中 $len $ 是数组长度，$n$ 是可使用员工数，$minProfit$ 是最小利润。
• 空间复杂度：$O(len\times n\times minProfit)$，其中 $len$ 是数组长度，$n$ 是可使用员工数，$minProfit$ 是最小利润，实现动态规划需要创建 $n\times minProfit$ 的二维数组 $dpTwoD$ 和 $len\times n\times minProfit$ 的三维数组 $dpThreeD$。

拓展