Weighted Activity Selection - Problem

You are given n activities where each activity has a start time, end time, and profit. Your goal is to select the maximum number of non-overlapping activities that maximizes the total profit.

Two activities are considered overlapping if one starts before the other ends. You need to use Dynamic Programming with Binary Search to solve this efficiently.

Input Format:

An array of activities where each activity is represented as [start_time, end_time, profit]

Output: Return the maximum profit achievable by selecting non-overlapping activities.

Input & Output

Example 1 — Basic Case

$ Input: activities = [[1,3,50],[2,5,20],[4,6,70],[6,8,30]]

› Output: 120

💡 Note: Select activities [1,3,50] and [4,6,70]. They don't overlap (first ends at 3, second starts at 4) and give maximum profit 50 + 70 = 120.

Example 2 — All Overlapping

$ Input: activities = [[1,4,30],[2,6,40],[5,8,20]]

› Output: 40

💡 Note: Activities [1,4,30] and [2,6,40] overlap, [2,6,40] and [5,8,20] overlap. Best choice is single activity [2,6,40] with profit 40.

Example 3 — Chain of Activities

$ Input: activities = [[1,2,100],[3,4,200],[5,6,300]]

› Output: 600

💡 Note: All three activities can be selected since none overlap: 1→2, 3→4, 5→6. Total profit = 100 + 200 + 300 = 600.

Constraints

1 ≤ activities.length ≤ 10⁴
activities[i].length == 3
0 ≤ start_i < end_i ≤ 10⁶
1 ≤ profit_i ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 M Microsoft 18 f Meta 15

The key insight is to sort activities by end time and use dynamic programming with binary search. For each activity, we decide whether to include it (its profit plus the best profit from compatible previous activities) or skip it. Binary search efficiently finds the latest non-overlapping activity. Best approach achieves O(n log n) time and O(n) space.

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(n × 2^n) Space: O(n)

Try every possible combination of activities (2^n possibilities), check if each combination has non-overlapping activities, and return the maximum profit found.

Dynamic Programming with Sorting

⏱️ Time: O(n²) Space: O(n)

Sort activities by end time, then for each activity decide whether to include it (profit + best profit before it) or skip it (keep previous best).

Optimal DP with Binary Search

⏱️ Time: O(n log n) Space: O(n)

Enhanced DP approach where binary search quickly finds the latest non-overlapping activity, reducing time complexity from O(n²) to O(n log n).

Brute Force - Try All Combinations — Algorithm Steps

Generate all 2^n possible subsets of activities
For each subset, verify no two activities overlap
Calculate total profit for valid subsets
Return the maximum profit found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all 2^n possible combinations using bit masks

Validate Each

Check if activities in subset don't overlap

Track Maximum

Keep the highest profit from valid combinations

Code -

solution.c — C

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

int solution(int activities[][3], int n) {
    int maxProfit = 0;
    
    // Try all 2^n possible combinations
    for (int mask = 0; mask < (1 << n); mask++) {
        int currentActivities[20][3]; // Assume max 20 activities
        int count = 0;
        int currentProfit = 0;
        
        // Build current subset
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                currentActivities[count][0] = activities[i][0];
                currentActivities[count][1] = activities[i][1];
                currentActivities[count][2] = activities[i][2];
                currentProfit += activities[i][2];
                count++;
            }
        }
        
        // Check if current subset is valid (non-overlapping)
        int valid = 1;
        for (int i = 0; i < count && valid; i++) {
            for (int j = i + 1; j < count; j++) {
                // Check overlap
                if (!(currentActivities[i][1] <= currentActivities[j][0] ||
                     currentActivities[j][1] <= currentActivities[i][0])) {
                    valid = 0;
                    break;
                }
            }
        }
        
        if (valid && currentProfit > maxProfit) {
            maxProfit = currentProfit;
        }
    }
    
    return maxProfit;
}

int main() {
    int activities[20][3];
    int n = 0;
    
    // Simple parser for activities input
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse [[a,b,c],[d,e,f]] format
    char *ptr = line + 1; // Skip first [
    while (*ptr && *ptr != ']' && n < 20) {
        if (*ptr == '[') {
            ptr++;
            sscanf(ptr, "%d,%d,%d", &activities[n][0], &activities[n][1], &activities[n][2]);
            n++;
            while (*ptr && *ptr != ']') ptr++;
            if (*ptr == ']') ptr++;
            if (*ptr == ',') ptr++;
        } else {
            ptr++;
        }
    }
    
    printf("%d\n", solution(activities, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^n)

2^n subsets to check, each requiring O(n) time to validate and sum

⚡ Linearithmic

Space Complexity

O(n)

Recursion stack depth for generating subsets

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~35 min Avg. Time

890 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

Weighted Activity Selection - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler