879. 盈利计划

2021-06-09 20:05:17 作者：互联网

题目

集团里有 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) 。

提示：
1 <= n <= 100
0 <= minProfit <= 100
1 <= group.length <= 100
1 <= group[i] <= 100
profit.length == group.length
0 <= profit[i] <= 100

回溯+记忆化

统计符合条件的计划数目可以使用回溯，但直接使用回溯会超时。这时需要牢记的一点是所有dp算法可以解决的问题都可以用记忆化回溯来解决！！！。确定一个状态需要剩余人数、利润下界和工作下标这三个值，每一个状态对应的dfs返回结果表示对应的盈利状态数，可以用一个三维数组来记录每一个返回结果。利润下界可能小于0，这样就无法作为数组下标，可以令minProfit=max(minProfit-profit[idx],0)。

    private int[][][] mem=new int[101][101][101];
    private int dfs(int n,int minProfit,int idx,int[] group,int[] profit){
        if(idx==group.length) return minProfit==0?1:0;
        else if(mem[n][minProfit][idx]!=-1) return mem[n][minProfit][idx];
        else if(n<group[idx]) {
            mem[n][minProfit][idx]=dfs(n,minProfit,idx+1,group,profit)%1000000007;
            return  mem[n][minProfit][idx];
        }
        else {
            int p=profit[idx],g=group[idx];
            mem[n][minProfit][idx]=dfs(n-group[idx],Math.max(minProfit-profit[idx],0),idx+1,group,profit)%1000000007;
            mem[n][minProfit][idx]+=dfs(n,minProfit,idx+1,group,profit)%1000000007;
            return mem[n][minProfit][idx]%1000000007;
        }
    }

    public int profitableSchemes(int n, int minProfit, int[] group, int[] profit) {
        for(int i=0;i<=100;++i){
            for(int j=0;j<=100;++j){
                Arrays.fill(mem[i][j],-1);
            }
        }
        return dfs(n,minProfit,0,group,profit);
    }

动态规划(三维背包问题)

定义 dp[i][j][k] 为考虑前 i 件物品，使用人数不超过 j，所得利润至少为 k 的方案数。
若不选择第i个物品则方案数为dp[i-1][j][k];若选择第i个物品则方案数为dp[i-1][j-group[i]][Math.max(k-profit[i],0)] (这里k-profit[i]可能小于0)。

    public int profitableSchemes(int n, int minProfit, int[] group, int[] profit) {
        int[][][] dp=new int[group.length+1][n+1][minProfit+1];
        for(int i=0;i<=n;++i) dp[0][i][0]=1;
        //j和k都是从0开始遍历
        for(int i=1;i<=group.length;++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-group[i-1]][Math.max(k-profit[i-1],0)]+dp[i-1][j][k];
                        dp[i][j][k]=dp[i][j][k]%1000000007;
                    }
                    else 
                        dp[i][j][k]=dp[i-1][j][k];
                }
            }
        } 
        return dp[group.length][n][minProfit];
    }

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/profitable-schemes
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

标签：group,idx,879,int,profit,minProfit,盈利,计划,dp
来源： https://www.cnblogs.com/Frank-Hong/p/14868288.html