879. Profitable Schemes

Hard (Khó) C++ Python 🔗 Xem trên LeetCode

📋 Đề Bài

There is a group of n members, and a list of various crimes they could commit. The ith crime generates a profit[i] and requires group[i] members to participate in it. If a 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 minProfit profit, and the total number of members participating in that subset of crimes is at most n.

Return the number of schemes that can be chosen. Since the answer may be very large, return it modulo 109 + 7.

 

Example 1:

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

Example 2:

Input: n = 10, minProfit = 5, group = [2,3,5], profit = [6,7,8]
Output: 7
Explanation: To make a profit of at least 5, the group 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).

 

Constraints:

  • 1 <= n <= 100
  • 0 <= minProfit <= 100
  • 1 <= group.length <= 100
  • 1 <= group[i] <= 100
  • profit.length == group.length
  • 0 <= profit[i] <= 100

🧠 Thuật Toán & Kỹ Thuật

Dynamic Programming (Quy hoạch động)
⏱️ Thời gian O(n×m)
💾 Không gian O(n×m)

💻 Lời Giải

C++ 0879-profitable-schemes.cpp 
class Solution {
public:
    int profitableSchemes(int n, int minProfit, vector<int>& group, vector<int>& profit) {
        const int m = group.size();
        const int MAXPROFIT = 101, MOD = 1e9 + 7;
        int dp[m + 1][MAXPROFIT + 1][n + 1];
        memset(dp, 0, sizeof(dp));
        
        for (int p = minProfit; p <= MAXPROFIT; ++p) {
            for (int k = 0; k <= n; ++k) {
                dp[m][p][k] = 1;
            }
        }
        
        for (int i = m - 1; i >= 0; --i) {
            for (int p = 0; p <= MAXPROFIT; ++p) {
                for (int k = 0; k <= n; ++k) {
                    dp[i][p][k] = dp[i + 1][p][k] % MOD;
                    if (k - group[i] >= 0) {
                        dp[i][p][k] = (dp[i][p][k] + dp[i + 1][min(p + profit[i], MAXPROFIT)][k - group[i]]) % MOD;
                    }
                }
            }
        }
        
        return dp[0][0][n];
    }
};
Python 0879-profitable-schemes.py 
class Solution:
    def profitableSchemes(self, n: int, minProfit: int, group: List[int], profit: List[int]) -> int:
        MOD = 10**9 + 7
        memo = {}
        
        def dp(i, p, n):
            if i == len(group):
                return 1 if p >= minProfit else 0
            
            if (i, p, n) in memo:
                return memo[(i, p, n)]
            
            res = dp(i + 1, p, n) % MOD
            if n - group[i] >= 0:
                res = (res + dp(i + 1, min(p + profit[i], 101), n - group[i])) % MOD
                
            memo[(i, p, n)] = res
            return res
        
        return dp(0, 0, n)