Profitable Schemes - Practice Coding Problems

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

Understanding the Visualization

Setup Crew

You have n members available and need at least minProfit total

Evaluate Heists

Each heist has specific member requirements and profit potential

Dynamic Planning

Use DP to count all valid combinations efficiently

Count Schemes

Sum all ways that meet profit goal with available crew

Key Takeaway

🎯 Key Insight: Use 3D DP to efficiently count all valid combinations by tracking members used and minimum profit achieved, avoiding the exponential complexity of brute force enumeration.

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

Approach	Time	Space	Notes
✓ 3D Dynamic Programming (Optimal)	O(n × m × minProfit)	O(n × minProfit)	Use 3D DP with states: crimes considered, members used, minimum profit achieved
Brute Force (Try All Subsets)	O(2^m)	O(1)	Generate all possible subsets of crimes and count valid profitable schemes

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>

int profitableSchemes(int n, int minProfit, int* group, int groupSize, int* profit, int profitSize) {
    const int MOD = 1000000007;
    
    // dp[i][j] = number of ways to use exactly i members and get at least j profit
    int** dp = (int**)malloc((n + 1) * sizeof(int*));
    for (int i = 0; i <= n; i++) {
        dp[i] = (int*)calloc(minProfit + 1, sizeof(int));
    }
    
    // Base case
    for (int i = 0; i <= n; i++) {
        dp[i][0] = 1;
    }
    
    // Process each crime
    for (int i = 0; i < groupSize; i++) {
        int g = group[i], p = profit[i];
        
        // Traverse backwards
        for (int j = n; j >= g; j--) {
            for (int k = minProfit; k >= 0; k--) {
                int prevProfit = (k - p) > 0 ? (k - p) : 0;
                dp[j][k] = (dp[j][k] + dp[j - g][prevProfit]) % MOD;
            }
        }
    }
    
    // Sum all ways
    int result = 0;
    for (int j = 0; j <= n; j++) {
        result = (result + dp[j][minProfit]) % MOD;
    }
    
    // Free memory
    for (int i = 0; i <= n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

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)

⚡ Linearithmic 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