Maximum Number of Events That Can Be Attended

Maximum Number of Events That Can Be Attended - Problem

Imagine you're a busy conference attendee trying to maximize your networking opportunities! You have a list of events happening over several days, and each event has a specific start day and end day.

You are given an array of events where events[i] = [startDayi, endDayi]. Every event i starts at startDayi and ends at endDayi.

Here's the challenge: You can attend any event i on any day d where startDayi ≤ d ≤ endDayi. However, you can only attend one event per day (no multitasking allowed!).

Goal: Return the maximum number of events you can attend.

This is a classic greedy scheduling problem that tests your ability to make optimal local decisions for a globally optimal solution.

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: You can attend all three events. Attend event 0 on day 1, event 1 on day 2, and event 2 on day 3.

example_2.py — Overlapping Events

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

› Output: 4

💡 Note: You can attend all four events. Attend the first [1,2] event on day 1, the second [1,2] event on day 2, the [2,3] event on day 3, and the [3,4] event on day 4.

example_3.py — Conflicting Events

$ Input: events = [[1,4],[4,4],[1,4],[4,4]]

› Output: 4

💡 Note: Events [1,4] can be attended on days 1, 2, 3 respectively, and both [4,4] events can be attended on day 4 (but only one can be attended, so we get maximum 4 total).

Visualization

Tap to expand

Understanding the Visualization

Identify Events

Each event has a start day and end day. You can attend it on any day within this range.

Sort by Urgency

Sort events by their end day - attend the most time-sensitive events first.

Greedy Selection

For each event, book it on the earliest available day to maximize future flexibility.

Count Attended

Count the total number of events you successfully scheduled.

Key Takeaway

🎯 Key Insight: Always attend events that end sooner first - this greedy choice maximizes your future scheduling flexibility!

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), and heap operations for each event take O(log n)

⚡ Linearithmic

Space Complexity

O(n)

Space for the heap to store occupied days

⚡ Linearithmic Space

Constraints

1 ≤ events.length ≤ 10⁵
events[i].length == 2
1 ≤ startDayi ≤ endDayi ≤ 10⁵
Each event lasts at least 1 day

Asked in

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

The optimal solution uses a greedy algorithm with sorting by end time. Key insight: always prioritize events that end sooner to maximize future opportunities. Sort events by end day, then for each event, attend it on the earliest available day within its range. Time complexity: O(n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Algorithm (Optimal)	O(n log n)	O(n)	Sort events by end time and greedily attend events that end earliest
Brute Force (Try All Combinations)	O(k^n)	O(n)	Try all possible ways to assign events to days

Greedy Algorithm (Optimal) — Algorithm Steps

Sort all events by their end day (ascending order)
Use a min-heap to track which days are occupied
For each event, try to attend it on the earliest possible day
If we can attend, add it to our count and mark the day as used
Remove days from heap that are before current event's start day

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by End Time

Sort all events by their ending day to prioritize urgent events

Greedy Selection

For each event, attend it on the earliest available day within its range

Mark Occupied

Mark the chosen day as occupied and move to next event

Code -

solution.c — C

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

#define MAX_DAYS 100005

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

int maxEvents(int** events, int eventsSize, int* eventsColSize) {
    // Sort events by end day
    qsort(events, eventsSize, sizeof(int*), compare);
    
    bool occupied[MAX_DAYS] = {false};
    int count = 0;
    
    for (int i = 0; i < eventsSize; i++) {
        int start = events[i][0], end = events[i][1];
        
        // Find earliest available day
        for (int day = start; day <= end; day++) {
            if (!occupied[day]) {
                occupied[day] = true;
                count++;
                break;
            }
        }
    }
    
    return count;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), and heap operations for each event take O(log n)

⚡ Linearithmic

Space Complexity

O(n)

Space for the heap to store occupied days

⚡ Linearithmic Space

Constraints

1 ≤ events.length ≤ 10⁵
events[i].length == 2
1 ≤ startDayi ≤ endDayi ≤ 10⁵
Each event lasts at least 1 day

28.6K Views

Medium Frequency

~25 min Avg. Time

892 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

Greedy Algorithm (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler