There are G people in a gang, and a list of various crimes they could commit.
The
i-th crime generates aprofit[i]and requiresgroup[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
Pprofit, 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 <= G <= 1000 <= P <= 1001 <= group[i] <= 1000 <= profit[i] <= 1001 <= 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/
原文：https://www.cnblogs.com/ruruozhenhao/p/10584393.html