Codestin Search App

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
✓ 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)	O(n³)	O(n)	For each new booking, check all possible triplets to ensure no three events overlap

Optimal: Track Bookings and Overlaps — Algorithm Steps

Maintain two lists: all bookings and current double-booked intervals
For each new booking, check if it overlaps with any double-booked interval
If it does overlap with a double-booked interval, reject (would create triple booking)
If safe, check against all existing bookings to find new double-bookings
Add any new overlaps to the double-booked intervals list
Add the booking to the bookings list and return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Overlaps List

First check if new booking conflicts with any double-booked intervals

Find New Overlaps

Check new booking against all existing bookings to identify new overlaps

Update Lists

Add new overlaps to overlaps list and new booking to bookings list

Return Success

Return true since no triple booking was created

Code -

solution.c — C

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

typedef struct {
    int** bookings;
    int** overlaps;
    int bookingsSize;
    int overlapsSize;
    int bookingsCapacity;
    int overlapsCapacity;
} MyCalendarTwo;

MyCalendarTwo* myCalendarTwoCreate() {
    MyCalendarTwo* obj = (MyCalendarTwo*)malloc(sizeof(MyCalendarTwo));
    obj->bookingsCapacity = 100;
    obj->overlapsCapacity = 100;
    obj->bookings = (int**)malloc(obj->bookingsCapacity * sizeof(int*));
    obj->overlaps = (int**)malloc(obj->overlapsCapacity * sizeof(int*));
    obj->bookingsSize = 0;
    obj->overlapsSize = 0;
    return obj;
}

bool myCalendarTwoBook(MyCalendarTwo* obj, int start, int end) {
    // First check if this booking would create a triple booking
    for (int i = 0; i < obj->overlapsSize; i++) {
        if (start < obj->overlaps[i][1] && end > obj->overlaps[i][0]) {
            return false; // Would create triple booking
        }
    }
    
    // Check against all existing bookings to find new overlaps
    for (int i = 0; i < obj->bookingsSize; i++) {
        if (start < obj->bookings[i][1] && end > obj->bookings[i][0]) {
            // Found an overlap, add it to overlaps list
            obj->overlaps[obj->overlapsSize] = (int*)malloc(2 * sizeof(int));
            obj->overlaps[obj->overlapsSize][0] = (start > obj->bookings[i][0]) ? start : obj->bookings[i][0];
            obj->overlaps[obj->overlapsSize][1] = (end < obj->bookings[i][1]) ? end : obj->bookings[i][1];
            obj->overlapsSize++;
        }
    }
    
    // Safe to add this booking
    obj->bookings[obj->bookingsSize] = (int*)malloc(2 * sizeof(int));
    obj->bookings[obj->bookingsSize][0] = start;
    obj->bookings[obj->bookingsSize][1] = end;
    obj->bookingsSize++;
    
    return true;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each booking operation checks against existing bookings and overlaps, which takes O(n) time

✓ Linear Growth

Space Complexity

O(n)

We store all bookings plus potentially O(n) overlapping intervals

⚡ 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

Optimal: Track Bookings and Overlaps — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler