Codestin Search App

My Calendar III - Problem

You're building a smart scheduling system that tracks booking overlaps in real-time. Every time someone books a time slot [startTime, endTime), you need to determine the maximum number of events that overlap at any point in time.

A k-booking occurs when k events have some non-empty time intersection - meaning there's at least one moment when all k events are happening simultaneously.

Your task: Implement the MyCalendarThree class that can:

MyCalendarThree() - Initialize an empty calendar
book(startTime, endTime) - Add a new booking and return the maximum overlap count across all bookings

Note: Time intervals are half-open [start, end), so an event ending at time t doesn't conflict with an event starting at time t.

Input & Output

example_1.py — Basic Booking Sequence

$ Input: myCalendarThree = MyCalendarThree() myCalendarThree.book(10, 20) # returns 1 myCalendarThree.book(50, 60) # returns 1 myCalendarThree.book(10, 40) # returns 2 myCalendarThree.book(5, 15) # returns 3 myCalendarThree.book(5, 10) # returns 3 myCalendarThree.book(25, 55) # returns 3

› Output: [1, 1, 2, 3, 3, 3]

💡 Note: First booking [10,20) has 1 overlap. Second [50,60) doesn't overlap, still max 1. Third [10,40) overlaps with first, max becomes 2. Fourth [5,15) overlaps with first two during [10,15), making max 3.

example_2.py — Edge Case with Adjacent Intervals

$ Input: myCalendarThree = MyCalendarThree() myCalendarThree.book(1, 2) # returns 1 myCalendarThree.book(2, 3) # returns 1 myCalendarThree.book(1, 3) # returns 2

› Output: [1, 1, 2]

💡 Note: [1,2) and [2,3) don't overlap since intervals are half-open. [1,3) overlaps with both but at different times, so max overlap is 2.

example_3.py — Same Time Intervals

$ Input: myCalendarThree = MyCalendarThree() myCalendarThree.book(5, 10) # returns 1 myCalendarThree.book(5, 10) # returns 2 myCalendarThree.book(5, 10) # returns 3

› Output: [1, 2, 3]

💡 Note: Three identical bookings [5,10) all completely overlap, creating a 3-booking at any time in [5,10).

Constraints

0 ≤ start < end ≤ 10⁹
At most 400 calls will be made to book
Time intervals are half-open: [start, end)

Visualization

Tap to expand

Understanding the Visualization

Add Booking Events

Mark each booking start with +1, each end with -1

Sort Time Points

Process all events in chronological order

Sweep Timeline

Maintain running count of active bookings

Track Maximum

The highest count reached is our k-booking answer

Key Takeaway

🎯 Key Insight: Instead of storing all intervals, we only track the net change in overlap count at critical time points, making updates efficient with O(log n) complexity per booking.

Asked in

G Google 45 a Amazon 32 ⊞ Microsoft 28 Apple 15

The optimal solution uses a difference array technique with a TreeMap to efficiently track booking overlaps. By marking +1 at start times and -1 at end times, we can compute the maximum overlap using prefix sums in O(n log n) time per operation.

Common Approaches

Approach	Time	Space	Notes
✓ Sweep Line with Coordinate Compression	O(n² log n)	O(n)	Use events at start/end times with sorting to efficiently track maximum overlaps
Difference Array (Optimal)	O(n log n)	O(n)	Use a TreeMap to maintain sorted time points with difference values for efficient overlap tracking
Brute Force (Store All Intervals)	O(n³)	O(n)	Store all bookings and check overlaps by iterating through all intervals for each booking

Sweep Line with Coordinate Compression — Algorithm Steps

Store all booking events as (time, +1/-1) pairs
For each new booking, add start event (+1) and end event (-1)
Sort all events by time
Sweep through events, maintaining running count and maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Events

Add +1 event at start time, -1 event at end time

Sort Events

Sort all events by time to process chronologically

Sweep Timeline

Process events left to right, tracking running count

Track Maximum

Keep track of maximum overlap seen during sweep

Code -

solution.c — C

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

typedef struct {
    int time;
    int delta;
} Event;

typedef struct {
    Event events[2000];
    int count;
} MyCalendarThree;

int compare(const void* a, const void* b) {
    return ((Event*)a)->time - ((Event*)b)->time;
}

MyCalendarThree* myCalendarThreeCreate() {
    MyCalendarThree* obj = (MyCalendarThree*)malloc(sizeof(MyCalendarThree));
    obj->count = 0;
    return obj;
}

int myCalendarThreeBook(MyCalendarThree* obj, int start, int end) {
    obj->events[obj->count++] = (Event){start, 1};
    obj->events[obj->count++] = (Event){end, -1};
    
    qsort(obj->events, obj->count, sizeof(Event), compare);
    
    int maxOverlap = 0;
    int currentOverlap = 0;
    
    for (int i = 0; i < obj->count; i++) {
        currentOverlap += obj->events[i].delta;
        if (currentOverlap > maxOverlap) {
            maxOverlap = currentOverlap;
        }
    }
    
    return maxOverlap;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

For each booking, we sort all events (O(n log n)) across n bookings

⚠ Quadratic Growth

Space Complexity

O(n)

Store 2n events (start and end for each booking)

⚡ Linearithmic Space

38.5K Views

Medium Frequency

~25 min Avg. Time

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

Sweep Line with Coordinate Compression — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler