zoukankan      html  css  js  c++  java
  • 879. Profitable Schemes

    There are G people in a gang, and a list of various crimes they could commit.

    The i-th crime generates a profit[i] and requires group[i] gang members to participate.

    If a gang member participates in one crime, that member can't participate in another crime.

    Let's call a profitable scheme any subset of these crimes that generates at least P profit, and the total number of gang members participating in that subset of crimes is at most G.

    How many schemes can be chosen?  Since the answer may be very large, return it modulo 10^9 + 7.

    Example 1:

    Input: G = 5, P = 3, group = [2,2], profit = [2,3]
    Output: 2
    Explanation: 
    To make a profit of at least 3, the gang could either commit crimes 0 and 1, or just crime 1.
    In total, there are 2 schemes.
    

    Example 2:

    Input: G = 10, P = 5, group = [2,3,5], profit = [6,7,8]
    Output: 7
    Explanation: 
    To make a profit of at least 5, the gang could commit any crimes, as long as they commit one.
    There are 7 possible schemes: (0), (1), (2), (0,1), (0,2), (1,2), and (0,1,2).

    Note:

    1. 1 <= G <= 100
    2. 0 <= P <= 100
    3. 1 <= group[i] <= 100
    4. 0 <= profit[i] <= 100
    5. 1 <= group.length = profit.length <= 100

    Approach #1: DP. [C++]

    class Solution {
    public:
        int profitableSchemes(int G, int P, vector<int>& group, vector<int>& profit) {
            const int mod = 1000000007;
            int K = group.size();
            vector<vector<vector<int>>> dp(K+1, vector<vector<int>>(P+1, vector<int>(G+1, 0)));
            dp[0][0][0] = 1;
            for (int k = 1; k <= K; ++k) {
                int p = profit[k-1];
                int g = group[k-1];
                for (int i = 0; i <= P; ++i) {
                    for (int j = 0; j <= G; ++j) {
                        dp[k][i][j] = (dp[k-1][i][j] + (j < g ? 0 : dp[k-1][max(0, i-p)][j-g])) % mod;
                    }
                }
            }
            
            return accumulate(begin(dp[K][P]), end(dp[K][P]), 0LL) % mod;
        }
    };
    

      

    Approach #2: DP. [Java]

    class Solution {
        private int mod = (int)1e9 + 7;
        public int profitableSchemes(int G, int P, int[] group, int[] profit) {
            int[][] dp = new int[G+1][P+1];
            dp[0][0] = 1;
            for (int k = 1; k <= group.length; ++k) {
                int g = group[k-1];
                int p = profit[k-1];
                for (int i = G; i >= g; --i) {
                    for (int j = P; j >= 0; --j) {
                        dp[i][j] = (dp[i][j] + dp[i-g][Math.max(0, j-p)]) % mod;
                    }
                }
            }
            int sum = 0;
            for (int i = 0; i <= G; ++i) 
                sum = (sum + dp[i][P]) % mod;
            
            return sum;
        }
    }
    

      

    Analysis:

    http://zxi.mytechroad.com/blog/dynamic-programming/leetcode-879-profitable-schemes/

    永远渴望,大智若愚(stay hungry, stay foolish)
  • 相关阅读:
    如何在windows下安装GIT
    TortoiseGit 安装
    高并发大流量专题---3、前端优化(减少HTTP请求次数)
    高并发大流量专题---2、流量优化(防盗链处理)
    高并发大流量专题---1、高并发大流量解决方案总结
    yii2和laravel比较
    php开发面试题---日常面试题1
    php开发面试题---禁用cookie之后,如何使用session
    剑指offer---4、序列化二叉树
    北风设计模式课程---20、UML类图介绍
  • 原文地址:https://www.cnblogs.com/h-hkai/p/10584393.html
Copyright © 2011-2022 走看看