LeetCode: 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 <= G <= 100
0 <= P <= 100
1 <= group[i] <= 100
0 <= profit[i] <= 100
1 <= group.length = profit.length <= 100

解题思路 —— 记忆搜索

记忆搜索。记 flag[G][P][k] 为从第 k 个犯罪开始， G 个罪犯， P 的收益， 最大的可能性。 深度优先搜索，并将计算的结果记录下来，下次出现时，直接返回。

AC 代码

class Solution {
public:
    // 从第 k 个犯罪开始， 最多G个罪犯，获取 P 的收益，的可能数
    int profitableSchemes(int flag[101][101][101], int G, int P, vector<int>& group, vector<int>& profit, int k)
    {
        if(k >= group.size() && P <= 0 && G >= 0) return 1;
        else if(G < 0 || k >= group.size()) return 0;

        if(flag[G][P][k] != 0) return flag[G][P][k]-1;
        int ans = 0;

        if(G >= group[k]) 
        {
            int tp = P - profit[k];
            if(tp < 0) tp = 0;
            ans = profitableSchemes(flag, G-group[k], tp, group, profit, k+1);
        }
        ans = (ans + profitableSchemes(flag, G, P, group, profit, k+1))%1000000007;

        flag[G][P][k] = ans+1;
        return ans;
    }
    int profitableSchemes(int G, int P, vector<int>& group, vector<int>& profit) 
    {
        int flag[101][101][101] = {0};
        return profitableSchemes(flag, G, P, group, profit, 0);
    }
};