Maximum Number of Events That Can Be Attended II

Maximum Number of Events That Can Be Attended II - Problem

Maximum Number of Events That Can Be Attended II

You are given an array of events where events[i] = [startDayi, endDayi, valuei]. Each event represents a business opportunity: the i-th event starts at startDayi and ends at endDayi, and if you attend this event, you will receive a value of valuei.

You are also given an integer k which represents the maximum number of events you can attend.

Important constraints:
• You can only attend one event at a time
• If you choose to attend an event, you must attend the entire event
• The end day is inclusive: you cannot attend two events where one starts and the other ends on the same day

Goal: Return the maximum sum of values that you can receive by attending at most k events strategically.

Input & Output

example_1.py — Basic Case

$ Input: events = [[1,2,4],[3,4,3],[2,3,1]], k = 2

› Output: 7

💡 Note: Choose events [1,2,4] and [3,4,3]. Total value = 4 + 3 = 7. These events don't overlap since first ends at day 2 and second starts at day 3.

example_2.py — Single Event Optimal

$ Input: events = [[1,2,4],[3,4,3],[2,3,10]], k = 2

› Output: 10

💡 Note: Although k=2, it's optimal to choose only one high-value event [2,3,10] rather than two lower-value events.

example_3.py — Maximum Capacity

$ Input: events = [[1,1,1],[2,2,2],[3,3,3],[4,4,4]], k = 3

› Output: 9

💡 Note: All events are non-overlapping. We can attend 3 events with maximum values: [2,2,2], [3,3,3], [4,4,4]. Total = 2+3+4 = 9.

Visualization

Tap to expand

Understanding the Visualization

Sort by End Time

Arrange all conferences by when they end - this helps us make optimal decisions

Find Compatible Events

For each conference, find the latest previous conference that doesn't overlap

Make Optimal Choice

Decide: attend this conference + best previous combination, or skip it entirely

Build Solution

Use DP to combine choices and find the maximum value achievable with k conferences

Key Takeaway

🎯 Key Insight: By sorting events by end time and using DP with binary search, we can efficiently explore all possible combinations while avoiding the exponential time complexity of brute force approaches.

Time & Space Complexity

Time Complexity

⏱️

O(n log n + nk)

O(n log n) for sorting, O(n log n) for binary search preprocessing, O(nk) for DP computation

⚡ Linearithmic

Space Complexity

O(nk)

DP table of size n×k to store optimal values for each subproblem

⚡ Linearithmic Space

Constraints

1 ≤ events.length ≤ 10⁶
events[i].length == 3
1 ≤ startDay_i ≤ endDay_i ≤ 10⁹
1 ≤ value_i ≤ 10⁶
1 ≤ k ≤ events.length

Asked in

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

This problem is optimally solved using Dynamic Programming with Binary Search. The key insights are: 1) Sort events by end time to enable optimal substructure, 2) Use binary search to efficiently find the latest non-overlapping event, and 3) Apply DP where dp[i][j] represents the maximum value using at most j events from the first i events. Time complexity is O(n log n + nk).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming + Binary Search (Optimal)	O(n log n + nk)	O(nk)	Sort events by end time, use DP with binary search to find optimal non-overlapping events
Brute Force (Try All Combinations)	O(2^n * n^2)	O(n)	Generate all possible combinations of k or fewer events and find the maximum valid sum

Dynamic Programming + Binary Search (Optimal) — Algorithm Steps

Sort events by their end times to enable optimal substructure
Use binary search to find the latest non-overlapping event for each event
Apply dynamic programming: dp[i][j] = max(dp[i-1][j], dp[prev][j-1] + value[i])
Return dp[n][k] as the maximum value achievable

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by End Time

Sort all events by their end times to enable optimal substructure

Binary Search Setup

For each event, use binary search to find latest non-overlapping event

DP Computation

Build DP table: dp[i][j] = max value using ≤j events from first i events

Optimal Decision

For each event, decide whether to include it or not based on maximum value

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    int* arr1 = *(int**)a;
    int* arr2 = *(int**)b;
    return arr1[1] - arr2[1]; // Sort by end time
}

int findLatestNonOverlapping(int** events, int i) {
    int left = 0, right = i - 1, result = -1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (events[mid][1] < events[i][0]) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return result;
}

int maxValue(int** events, int n, int k) {
    qsort(events, n, sizeof(int*), compare);
    
    // Create DP table
    int** dp = malloc((n + 1) * sizeof(int*));
    for (int i = 0; i <= n; i++) {
        dp[i] = calloc(k + 1, sizeof(int));
    }
    
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= k; j++) {
            // Option 1: Don't take current event
            dp[i][j] = dp[i-1][j];
            
            // Option 2: Take current event
            int prev = findLatestNonOverlapping(events, i-1);
            int newVal;
            if (prev == -1) {
                newVal = events[i-1][2];
            } else {
                newVal = dp[prev+1][j-1] + events[i-1][2];
            }
            
            if (newVal > dp[i][j]) {
                dp[i][j] = newVal;
            }
        }
    }
    
    int result = dp[n][k];
    
    // Free memory
    for (int i = 0; i <= n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    
    int** events = malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        events[i] = malloc(3 * sizeof(int));
        scanf("%d %d %d", &events[i][0], &events[i][1], &events[i][2]);
    }
    
    printf("%d\n", maxValue(events, n, k));
    
    for (int i = 0; i < n; i++) {
        free(events[i]);
    }
    free(events);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + nk)

O(n log n) for sorting, O(n log n) for binary search preprocessing, O(nk) for DP computation

⚡ Linearithmic

Space Complexity

O(nk)

DP table of size n×k to store optimal values for each subproblem

⚡ Linearithmic Space

Constraints

1 ≤ events.length ≤ 10⁶
events[i].length == 3
1 ≤ startDay_i ≤ endDay_i ≤ 10⁹
1 ≤ value_i ≤ 10⁶
1 ≤ k ≤ events.length

42.8K Views

High Frequency

~25 min Avg. Time

1.4K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming + Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler