My Calendar II

My Calendar II - Problem

Array Binary Search Design Segment Tree Prefix Sum Ordered Set Medium

You are implementing a program to use as your calendar. We can add a new event if adding the event will not cause a triple booking.

A triple booking happens when three events have some non-empty intersection (i.e., some moment is common to all the three events).

The event can be represented as a pair of integers startTime and endTime that represents a booking on the half-open interval [startTime, endTime), the range of real numbers x such that startTime <= x < endTime.

Implement the MyCalendarTwo class:

MyCalendarTwo() Initializes the calendar object.
boolean book(int startTime, int endTime) Returns true if the event can be added to the calendar successfully without causing a triple booking. Otherwise, return false and do not add the event to the calendar.

Input & Output

Example 1 — Basic Calendar Operations

$ Input: operations = ["MyCalendarTwo", "book", "book", "book"], parameters = [[], [10,20], [50,60], [10,40]]

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

💡 Note: First booking [10,20) succeeds. Second booking [50,60) succeeds (no overlap). Third booking [10,40) would overlap with [10,20) creating double booking, but since it would also create triple overlap at time 10-20, it's rejected.

Example 2 — Double Booking Allowed

$ Input: operations = ["MyCalendarTwo", "book", "book", "book", "book"], parameters = [[], [10,20], [15,25], [20,30], [5,15]]

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

💡 Note: First three bookings create overlapping regions but no triple booking. Fourth booking [5,15] would create triple overlap in range [10,15], so it's rejected.

Example 3 — Edge Case with Same Times

$ Input: operations = ["MyCalendarTwo", "book", "book"], parameters = [[], [1,2], [2,3]]

› Output: [null, true, true]

💡 Note: Intervals [1,2) and [2,3) don't overlap since the first ends exactly when the second starts (half-open intervals).

Constraints

0 ≤ startTime < endTime ≤ 10⁹
At most 1000 calls will be made to book

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is to track overlapping regions separately from single bookings. The best approach maintains two lists: single bookings and double bookings (overlapping regions). When a new booking arrives, first check if it overlaps with any double booking (which would create a triple). If not, find overlaps with single bookings and add them to double bookings. Time: O(n²), Space: O(n²)

Common Approaches

✓ Event-Based Sweep Line

⏱️ Time: O(n² log n) Space: O(n)

Convert each booking to start/end events, sort by time, then sweep through timeline counting active bookings. If adding a new booking would cause more than 2 concurrent bookings at any point, reject it.

Track All Bookings and Check Overlaps

⏱️ Time: O(n³) Space: O(n)

For each booking request, check if it would create a triple overlap with any two existing bookings. This involves checking all possible combinations of the new booking with pairs of existing bookings.

Track Single and Double Bookings

⏱️ Time: O(n²) Space: O(n²)

Keep two lists: one for all bookings and one for double bookings (overlapping regions). When a new booking comes, first check if it overlaps with any double booking (which would create triple). If not, add overlaps with existing bookings to the double bookings list.

Event-Based Sweep Line — Algorithm Steps

Convert all bookings to start (+1) and end (-1) events
Sort events by time
Sweep through timeline counting active bookings
If count exceeds 2 at any point with new booking, reject

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Events

Convert bookings to start/end events

Sort & Sweep

Sort by time and sweep counting active bookings

Check Limit

If active count exceeds 2, reject booking

Code -

solution.c — C

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

#define MAX_COMMANDS 1000
#define MAX_LINE 10000

// --- Math Helpers ---
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }

// --- Calendar Logic ---

typedef struct {
    int bookings[1000][2];
    int b_count;
    // We need to store overlaps to detect triple bookings
    // An overlap implies 2 events are already there. 
    // Adding a 3rd event to an overlap region is forbidden.
    int overlaps[2000][2]; 
    int o_count;
} MyCalendarTwo;

MyCalendarTwo* myCalendarTwoCreate() {
    MyCalendarTwo* obj = (MyCalendarTwo*)malloc(sizeof(MyCalendarTwo));
    if (obj) {
        obj->b_count = 0;
        obj->o_count = 0;
    }
    return obj;
}

bool myCalendarTwoBook(MyCalendarTwo* obj, int start, int end) {
    if (!obj) return false;

    // 1. Check if the new booking overlaps with any EXISTING double-overlap
    //    If it does, that would make a triple booking -> return false.
    for (int i = 0; i < obj->o_count; i++) {
        int os = obj->overlaps[i][0];
        int oe = obj->overlaps[i][1];
        
        // Intersection check: max(start, os) < min(end, oe)
        if (max(start, os) < min(end, oe)) {
            return false; 
        }
    }

    // 2. The booking is valid. Now we must:
    //    a) Add new overlaps created by this booking + existing bookings
    //    b) Add the booking itself to the list
    for (int i = 0; i < obj->b_count; i++) {
        int bs = obj->bookings[i][0];
        int be = obj->bookings[i][1];
        
        int is = max(start, bs);
        int ie = min(end, be);
        
        // If there is an intersection, record it in the overlaps list
        if (is < ie) {
            if (obj->o_count < 2000) {
                obj->overlaps[obj->o_count][0] = is;
                obj->overlaps[obj->o_count][1] = ie;
                obj->o_count++;
            }
        }
    }

    // Add the actual booking
    if (obj->b_count < 1000) {
        obj->bookings[obj->b_count][0] = start;
        obj->bookings[obj->b_count][1] = end;
        obj->b_count++;
    }
    
    return true;
}

// --- Parsing Logic ---

static char commands[MAX_COMMANDS][20];
static int parameters[MAX_COMMANDS][2];
static char results[MAX_COMMANDS][10];

void parseCommands(char* str, int* cmdCount) {
    *cmdCount = 0;
    char* p = str;
    
    while (*p) {
        if (*p == '"') {
            p++; 
            char* start = p;
            while (*p && *p != '"') p++;
            
            if (*p == '"') {
                *p = '\0';
                if (*cmdCount < MAX_COMMANDS) {
                    strcpy(commands[*cmdCount], start);
                    (*cmdCount)++;
                }
                *p = '"';
                p++;
            }
        } else {
            p++;
        }
    }
}

void parseParameters(char* str, int* paramCount) {
    *paramCount = 0;
    char* p = str;
    
    // Find start of outer list
    char* outer = strchr(p, '[');
    if (!outer) return;
    p = outer + 1;

    while (*p) {
        // Find start of inner list
        if (*p == '[') {
            p++;
            // Check for empty params "[]"
            while (isspace(*p)) p++;
            
            if (*p == ']') {
                parameters[*paramCount][0] = 0;
                parameters[*paramCount][1] = 0;
                (*paramCount)++;
                p++;
            } else {
                int val1 = (int)strtol(p, &p, 10);
                while (*p && (isspace(*p) || *p == ',')) p++;
                int val2 = (int)strtol(p, &p, 10);
                
                if (*paramCount < MAX_COMMANDS) {
                    parameters[*paramCount][0] = val1;
                    parameters[*paramCount][1] = val2;
                    (*paramCount)++;
                }
                while (*p && *p != ']') p++;
                if (*p == ']') p++;
            }
        } else {
            p++;
        }
    }
}

// --- Main ---

int main() {
    char line[MAX_LINE];
    int cmdCount = 0;
    int paramCount = 0;

    // Read Input
    if (!fgets(line, MAX_LINE, stdin)) return 0;
    parseCommands(line, &cmdCount);

    if (!fgets(line, MAX_LINE, stdin)) return 0;
    parseParameters(line, &paramCount);

    MyCalendarTwo* calendar = NULL;

    // Execute
    for (int i = 0; i < cmdCount; i++) {
        if (strcmp(commands[i], "MyCalendarTwo") == 0) {
            calendar = myCalendarTwoCreate();
            strcpy(results[i], "null");
        } else if (strcmp(commands[i], "book") == 0) {
            if (calendar) {
                bool res = myCalendarTwoBook(calendar, parameters[i][0], parameters[i][1]);
                strcpy(results[i], res ? "true" : "false");
            }
        }
    }

    // Output
    printf("[");
    for (int i = 0; i < cmdCount; i++) {
        if (i > 0) printf(",");
        printf("%s", results[i]);
    }
    printf("]\n");

    if (calendar) free(calendar);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

For each booking, we sort all events O(n log n) and then process them O(n)

⚠ Quadratic Growth

Space Complexity

O(n)

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

⚠ Quadratic Space

67.0K Views

Medium Frequency

~25 min Avg. Time

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

Event-Based Sweep Line — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler