其他分享
首页 > 其他分享> > 879. 盈利计划

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) 。

提示:
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