Two Best Non-Overlapping Events - Practice Coding Problems

Two Best Non-Overlapping Events - Problem

Array Binary Search Dynamic Programming Sorting Heap (Priority Queue) Medium

Imagine you're a time management consultant helping someone maximize their value from attending events. You have a list of events, each with a start time, end time, and value they'll gain by attending.

Your goal is to select at most two non-overlapping events that maximize the total value. Events are considered overlapping if one starts before or when another ends - there must be at least a 1-unit gap between events.

Input: A 2D array events where events[i] = [startTime, endTime, value]

Output: The maximum sum of values from selecting up to 2 non-overlapping events

Example: If you have events [[1,3,2], [4,5,2], [2,4,3]], you could pick events 1 and 2 for a total value of 4, since event 1 ends at time 3 and event 2 starts at time 4.

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: We can choose events [1,3,2] and [4,5,2]. Event 1 ends at time 3, and event 2 starts at time 4, so they don't overlap. Total value = 2 + 2 = 4.

example_2.py — Overlapping Events

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

› Output: 5

💡 Note: The optimal choice is to attend only the event [1,5,5] which gives value 5. Although we could attend [1,3,2] and [4,5,2] for value 4, the single event [1,5,5] is better.

example_3.py — Single Event

$ Input: events = [[1,5,3]]

› Output: 3

💡 Note: There's only one event, so we attend it and get value 3.

Constraints

2 ≤ events.length ≤ 10⁵
events[i].length == 3
1 ≤ startTime_i ≤ endTime_i ≤ 10⁹
1 ≤ value_i ≤ 10⁶
You can attend at most 2 events

Visualization

Tap to expand

Understanding the Visualization

Timeline Setup

Place all events on a timeline ordered by their end times

Value Tracking

Keep track of the maximum value achievable up to each point

Binary Search

For each event, quickly find the best compatible previous event

Optimal Combination

Combine current event with the best previous event found

Key Takeaway

🎯 Key Insight: Sorting by end time + binary search allows us to efficiently find compatible events in O(n log n) time instead of O(n²)

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses sorting and binary search to achieve O(n log n) complexity. By sorting events by end time and maintaining a cumulative maximum array, we can efficiently find the best compatible previous event for each current event using binary search.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Binary Search (Optimal)	O(n log n)	O(n)	Sort events by end time, then use binary search to find the best compatible previous event
Brute Force (Check All Pairs)	O(n²)	O(1)	Check every possible pair of events and single events to find maximum value

Sorting + Binary Search (Optimal) — Algorithm Steps

Sort events by end time to enable efficient searching
Create arrays to track maximum values seen up to each position
For each event, use binary search to find the latest non-overlapping previous event
Combine the current event's value with the best previous value found
Track and return the maximum value across all combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by End Time

Sort all events by their end times to enable binary search

Build Max Array

Create cumulative maximum values for quick lookups

Binary Search

For each event, binary search for the best compatible previous event

Combine Values

Add current event value to the best previous event value

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int compare(const void* a, const void* b) {
    int* eventA = *(int**)a;
    int* eventB = *(int**)b;
    return eventA[1] - eventB[1];
}

int maxTwoEvents(int** events, int eventsSize, int* eventsColSize) {
    // Sort events by end time
    qsort(events, eventsSize, sizeof(int*), compare);
    
    // Track maximum value seen up to each position
    int* maxVal = (int*)malloc(eventsSize * sizeof(int));
    maxVal[0] = events[0][2];
    
    for (int i = 1; i < eventsSize; i++) {
        maxVal[i] = max(maxVal[i-1], events[i][2]);
    }
    
    int maxSum = maxVal[eventsSize-1]; // Single event maximum
    
    // For each event, find best compatible previous event
    for (int i = 0; i < eventsSize; i++) {
        int currStart = events[i][0];
        int currVal = events[i][2];
        
        // Binary search for latest event that ends before currStart
        int left = 0, right = i - 1;
        int bestIdx = -1;
        
        while (left <= right) {
            int mid = (left + right) / 2;
            if (events[mid][1] < currStart) {
                bestIdx = mid;
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        
        // If found compatible event, update maximum
        if (bestIdx != -1) {
            maxSum = max(maxSum, currVal + maxVal[bestIdx]);
        }
    }
    
    free(maxVal);
    return maxSum;
}

int main() {
    int events[][3] = {{1,3,2},{4,5,2},{2,4,3}};
    int* eventPtrs[3] = {events[0], events[1], events[2]};
    int colSizes[3] = {3, 3, 3};
    
    printf("%d\n", maxTwoEvents(eventPtrs, 3, colSizes));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n log n) for n binary searches = O(n log n) total

⚡ Linearithmic

Space Complexity

O(n)

Additional arrays to store sorted events and track maximum values

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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

Sorting + Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler