Profitable Schemes

Profitable Schemes - Problem

Criminal Organization Planning Challenge

You're managing a criminal organization with n members who need to plan their operations strategically. You have a list of potential crimes, where each crime i:
• Generates profit[i] money
• Requires exactly group[i] members to execute

Important constraint: Each member can only participate in one crime - no member can be involved in multiple operations.

Your goal is to find how many different profitable schemes exist. A profitable scheme is any combination of crimes that:
1. Generates at least minProfit total profit
2. Uses at most n total members

Since the answer can be extremely large, return it modulo 10^9 + 7.

Example: With 3 members, minProfit=2, profits=[2,3,1], groups=[2,1,1]
You could choose crime 0 (profit=2, uses 2 members) OR crimes 1+2 (profit=4, uses 2 members) = 2 schemes

Input & Output

example_1.py — Basic Case

$ Input: n = 5, minProfit = 3, group = [2,2], profit = [2,3]

› Output: 2

💡 Note: We can form 2 profitable schemes: choose crime 1 alone (profit=3, members=2) OR choose both crimes (profit=5, members=4). Both satisfy minProfit ≥ 3 and members ≤ 5.

example_2.py — Multiple Options

$ Input: n = 10, minProfit = 5, group = [2,3,5], profit = [6,7,8]

› Output: 7

💡 Note: Multiple combinations work: {0}, {1}, {2}, {0,1}, {0,2}, {1,2}, {0,1,2}. Each achieves profit ≥ 5 with members ≤ 10.

example_3.py — Edge Case

$ Input: n = 1, minProfit = 1, group = [1,1,1], profit = [1,1,1]

› Output: 3

💡 Note: With only 1 member available, we can choose any single crime. Each crime uses exactly 1 member and generates profit 1, meeting our minimum requirement.

Constraints

1 ≤ n ≤ 100
0 ≤ minProfit ≤ 100
1 ≤ group.length ≤ 100
1 ≤ group[i] ≤ 100
0 ≤ profit[i] ≤ 100
Note: Each member can participate in at most one crime

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses 3D Dynamic Programming with states tracking crimes considered, members used, and minimum profit achieved. The key insight is to use dp[j][k] representing the number of ways to use exactly j members and achieve at least k profit. We process crimes one by one and update states based on whether to include each crime or not. Time complexity: O(n × m × minProfit).

Common Approaches

✓ 3D Dynamic Programming (Optimal)

⏱️ Time: O(n × m × minProfit) Space: O(n × minProfit)

The optimal solution uses 3D dynamic programming where dp[i][j][k] represents the number of ways to achieve exactly j members used and at least k profit using the first i crimes. We can optimize space by using 2D arrays and processing crimes one by one.

Brute Force (Try All Subsets)

⏱️ Time: O(2^m) Space: O(1)

Generate every possible subset of crimes using bit manipulation or recursion. For each subset, calculate total members used and total profit gained. Count how many subsets satisfy both constraints: members <= n and profit >= minProfit.

3D Dynamic Programming (Optimal) — Algorithm Steps

Initialize DP table: dp[members][profit] = number of ways
Base case: dp[0][0] = 1 (one way to use 0 members and get 0 profit)
For each crime, update DP table by either taking or not taking the crime
Sum all dp[j][minProfit] for j from 0 to n to get final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Base Case

dp[i][0] = 1 for all i (one way to achieve 0 profit)

Process Each Crime

For each crime, decide to take it or not

Update States

dp[j][k] += dp[j-group[i]][max(0,k-profit[i])]

Sum Final States

Sum dp[j][minProfit] for all valid j

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static int dp[105][105];
static int old[105][105];

int profitableSchemes(int n, int minProfit, int* group, int groupSize, int* profit, int profitSize) {
    const int MOD = 1000000007;
    
    for (int i = 0; i <= n; i++)
        for (int j = 0; j <= minProfit; j++)
            dp[i][j] = 0;
    
    for (int i = 0; i <= n; i++)
        dp[i][0] = 1;
    
    for (int idx = 0; idx < groupSize; idx++) {
        int g = group[idx], p = profit[idx];
        
        for (int i = 0; i <= n; i++)
            for (int j = 0; j <= minProfit; j++)
                old[i][j] = dp[i][j];
        
        for (int i = g; i <= n; i++) {
            for (int j = 0; j <= minProfit; j++) {
                int newProfit = j + p;
                if (newProfit > minProfit) newProfit = minProfit;
                dp[i][newProfit] = (dp[i][newProfit] + old[i - g][j]) % MOD;
            }
        }
    }
    
    return dp[n][minProfit];
}

int parseArray(char* line, int* arr) {
    // Strip brackets
    char* start = line;
    int len = strlen(line);
    if (len > 0 && line[0] == '[') start++;
    if (len > 0 && line[len-1] == ']') line[len-1] = '\0';
    
    if (strlen(start) == 0 || strcmp(start, "]") == 0) return 0;
    
    int count = 0;
    char* token = strtok(start, ",");
    while (token != NULL) {
        arr[count++] = atoi(token);
        token = strtok(NULL, ",");
    }
    return count;
}

int main() {
    int n, minProfit;
    scanf("%d", &n);
    scanf("%d", &minProfit);
    
    char groupLine[1000], profitLine[1000];
    scanf("%s", groupLine);
    scanf("%s", profitLine);
    
    int group[100], profit[100];
    int groupSize = parseArray(groupLine, group);
    int profitSize = parseArray(profitLine, profit);
    
    printf("%d\n", profitableSchemes(n, minProfit, group, groupSize, profit, profitSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m × minProfit)

We iterate through m crimes, and for each crime we update O(n × minProfit) states

✓ Linear Growth

Space Complexity

O(n × minProfit)

We maintain a 2D DP table of size (n+1) × (minProfit+1)

✓ Linear Space

42.3K Views

Medium Frequency

~25 min Avg. Time

1.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

3D Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler