My Calendar II - Practice Coding Problems

My Calendar II - Problem

Array Binary Search Design Segment Tree Prefix Sum Ordered Set Medium

My Calendar II is an advanced calendar booking system that prevents triple bookings. You need to implement a smart calendar that can track overlapping events and reject any booking that would create a situation where three events overlap at the same time.

Think of it like a conference room booking system - while double bookings might be manageable (perhaps one meeting can use half the room), triple bookings are absolutely not allowed as they would create chaos!

Each event is represented as a half-open interval [startTime, endTime), meaning it includes the start time but excludes the end time. Your calendar should:
• Accept bookings that don't create triple overlaps
• Reject bookings that would cause three events to share common time
• Return true for successful bookings, false for rejected ones

Example: If you have events [10,20) and [15,25), you can still book [17,22) because only two overlap. But booking another event like [18,23) would be rejected since all four time periods [18,20), [18,22), [18,23), and [18,25) would have three events overlapping.

Input & Output

example_1.py — Basic Usage

$ Input: myCalendarTwo = MyCalendarTwo() myCalendarTwo.book(10, 20) // return True myCalendarTwo.book(50, 60) // return True myCalendarTwo.book(10, 40) // return True myCalendarTwo.book(5, 15) // return False myCalendarTwo.book(5, 10) // return True myCalendarTwo.book(25, 55) // return True

› Output: [null, true, true, true, false, true, true]

💡 Note: First three bookings succeed. The fourth booking [5,15) would create a triple overlap with [10,20) and [10,40) in the time period [10,15), so it's rejected. The fifth booking [5,10) is accepted since it doesn't create a triple overlap. The sixth booking [25,55) is also accepted.

example_2.py — Edge Cases

$ Input: myCalendarTwo = MyCalendarTwo() myCalendarTwo.book(10, 20) // return True myCalendarTwo.book(15, 25) // return True myCalendarTwo.book(20, 30) // return True myCalendarTwo.book(15, 20) // return False

› Output: [null, true, true, true, false]

💡 Note: The first three bookings create overlaps [15,20) and [20,25). When we try to book [15,20), it would overlap completely with the existing double-booked interval [15,20), creating a triple booking, so it's rejected.

example_3.py — No Conflicts

$ Input: myCalendarTwo = MyCalendarTwo() myCalendarTwo.book(10, 15) // return True myCalendarTwo.book(20, 25) // return True myCalendarTwo.book(30, 35) // return True myCalendarTwo.book(40, 45) // return True

› Output: [null, true, true, true, true]

💡 Note: All bookings are accepted because none of them overlap with each other, so there are no double bookings and certainly no triple bookings.

Constraints

0 ≤ start < end ≤ 10⁹
At most 1000 calls will be made to book
All time values are integers
Intervals are half-open: [start, end)

Visualization

Tap to expand

Understanding the Visualization

Check Danger Zone

First check if the new booking would overlap with any currently double-booked time slots (the danger zone)

Scan for New Conflicts

If safe, scan through all existing bookings to identify any new overlaps the new booking would create

Update Tracking Lists

Add any newly discovered overlaps to the double-booked intervals list for future conflict checking

Accept Booking

Add the new booking to the accepted bookings list and return success

Key Takeaway

🎯 Key Insight: By separating all bookings from double-booked intervals, we can efficiently detect potential triple bookings in O(n) time per operation, making the calendar system scalable and responsive.

Asked in

G Google 42 ⊞ Microsoft 28 a Amazon 35 Apple 15

The optimal solution uses a two-list approach to efficiently prevent triple bookings. We maintain one list for all accepted bookings and another for double-booked intervals. For each new booking, we first check if it would overlap with any existing double-booked interval (which would create a triple booking), and if safe, we identify any new overlaps it creates with existing bookings. This approach achieves O(n) time complexity per booking operation, making it much more efficient than the brute force O(n³) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Combinations)	O(n³)	O(n)	For each new booking, check all possible triplets to ensure no three events overlap
Optimal: Track Bookings and Overlaps	O(n)	O(n)	Maintain separate lists for all bookings and double-booked intervals, check new bookings against existing overlaps

Brute Force (Check All Combinations) — Algorithm Steps

Store all accepted bookings in a list
For each new booking request, add it temporarily to the list
Check all possible triplets of events for overlaps
If any triplet has a common intersection, reject the booking
Otherwise, accept the booking and add it permanently

Visualization

Tap to expand

Step-by-Step Walkthrough

Add New Booking

Temporarily add the new booking to our list

Generate Triplets

Generate all possible combinations of three bookings

Check Overlaps

For each triplet, check if all three intervals have a common intersection

Decision

If any triplet overlaps, reject the booking; otherwise accept it

Code -

solution.c — C

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

typedef struct {
    int** bookings;
    int size;
    int capacity;
} MyCalendarTwo;

MyCalendarTwo* myCalendarTwoCreate() {
    MyCalendarTwo* obj = (MyCalendarTwo*)malloc(sizeof(MyCalendarTwo));
    obj->capacity = 100;
    obj->bookings = (int**)malloc(obj->capacity * sizeof(int*));
    obj->size = 0;
    return obj;
}

bool hasTripleOverlap(int* event1, int* event2, int* event3) {
    int start = (event1[0] > event2[0]) ? event1[0] : event2[0];
    start = (start > event3[0]) ? start : event3[0];
    
    int end = (event1[1] < event2[1]) ? event1[1] : event2[1];
    end = (end < event3[1]) ? end : event3[1];
    
    return start < end;
}

bool myCalendarTwoBook(MyCalendarTwo* obj, int start, int end) {
    // Add the new booking temporarily
    obj->bookings[obj->size] = (int*)malloc(2 * sizeof(int));
    obj->bookings[obj->size][0] = start;
    obj->bookings[obj->size][1] = end;
    obj->size++;
    
    // Check all possible triplets
    for (int i = 0; i < obj->size; i++) {
        for (int j = i + 1; j < obj->size; j++) {
            for (int k = j + 1; k < obj->size; k++) {
                if (hasTripleOverlap(obj->bookings[i], obj->bookings[j], obj->bookings[k])) {
                    free(obj->bookings[obj->size - 1]);
                    obj->size--;
                    return false;
                }
            }
        }
    }
    
    return true;
}

void myCalendarTwoFree(MyCalendarTwo* obj) {
    for (int i = 0; i < obj->size; i++) {
        free(obj->bookings[i]);
    }
    free(obj->bookings);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each booking, we potentially check all triplets of events, leading to cubic time complexity

⚠ Quadratic Growth

Space Complexity

O(n)

We store all n bookings in memory

⚡ Linearithmic Space

58.0K Views

Medium-High Frequency

~25 min Avg. Time

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

Brute Force (Check All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler