My Calendar III

My Calendar III - Problem

A k-booking happens when k events have some non-empty intersection (i.e., there is some time that is common to all k events.)

You are given some events [startTime, endTime), after each given event, return an integer k representing the maximum k-booking between all the previous events.

Implement the MyCalendarThree class:

MyCalendarThree() Initializes the object.
int book(int startTime, int endTime) Returns an integer k representing the largest integer such that there exists a k-booking in the calendar.

Input & Output

Example 1 — Basic Booking Sequence

$ Input: operations = ["MyCalendarThree","book","book","book"], values = [[],[10,20],[15,25],[20,30]]

› Output: [1,2,2]

💡 Note: First book(10,20) returns 1. Second book(15,25) overlaps with first, max k-booking is 2. Third book(20,30) doesn't increase maximum overlap, still 2.

Example 2 — Multiple Overlaps

$ Input: operations = ["MyCalendarThree","book","book","book","book"], values = [[],[10,40],[20,30],[25,35],[5,15]]

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

💡 Note: Progressive overlap: first booking alone (1), second overlaps with first (2), third overlaps with both first and second at time 25-30 (3), fourth doesn't increase maximum.

Constraints

0 ≤ start < end ≤ 10⁹
At most 400 calls will be made to book

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The optimal approach uses a difference array technique with a map. We increment the count at start time and decrement at end time, then calculate the prefix sum to find maximum overlapping bookings. Time: O(n²), Space: O(n)

Common Approaches

✓ Brute Force with List Storage

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

For each new booking, store the interval and check all previous intervals to count the maximum number of overlapping events at any time point.

Difference Array with Map

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

Maintain a map where we increment at start time and decrement at end time. The maximum prefix sum gives us the maximum k-booking.

Brute Force with List Storage — Algorithm Steps

Store each booking interval
For each booking, iterate through all time points
Count overlapping intervals at each point

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Intervals

Add new booking to list

Check All Points

Count overlaps at each time point

Return Maximum

Return highest overlap count

Code -

solution.c — C

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

#define MAX_EVENTS 2000
#define MAX_OPERATIONS 100

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

static Event events[MAX_EVENTS];
static int event_count = 0;

typedef struct {
    int dummy; // placeholder
} MyCalendarThree;

MyCalendarThree* myCalendarThreeCreate() {
    MyCalendarThree* obj = (MyCalendarThree*)malloc(sizeof(MyCalendarThree));
    event_count = 0;
    return obj;
}

int compareEvents(const void* a, const void* b) {
    Event* ea = (Event*)a;
    Event* eb = (Event*)b;
    return ea->time - eb->time;
}

int myCalendarThreeBook(MyCalendarThree* obj, int start, int end) {
    // Add start event (+1) and end event (-1)
    int startIdx = -1;
    for (int i = 0; i < event_count; i++) {
        if (events[i].time == start) {
            startIdx = i;
            break;
        }
    }
    if (startIdx == -1) {
        events[event_count].time = start;
        events[event_count].delta = 0;
        startIdx = event_count;
        event_count++;
    }
    events[startIdx].delta = events[startIdx].delta + 1;
    
    int endIdx = -1;
    for (int i = 0; i < event_count; i++) {
        if (events[i].time == end) {
            endIdx = i;
            break;
        }
    }
    if (endIdx == -1) {
        events[event_count].time = end;
        events[event_count].delta = 0;
        endIdx = event_count;
        event_count++;
    }
    events[endIdx].delta = events[endIdx].delta - 1;
    
    // Sort events by time
    qsort(events, event_count, sizeof(Event), compareEvents);
    
    // Sweep line to find maximum overlap
    int max_k = 0;
    int current_k = 0;
    
    for (int i = 0; i < event_count; i++) {
        current_k += events[i].delta;
        if (current_k > max_k) {
            max_k = current_k;
        }
    }
    
    return max_k;
}

int parseOperations(const char* line, char operations[][20]) {
    int count = 0;
    const char* p = line;
    while ((p = strchr(p, '"')) != NULL) {
        p++; // Skip opening quote
        const char* end = strchr(p, '"');
        if (end != NULL) {
            int len = end - p;
            strncpy(operations[count], p, len);
            operations[count][len] = '\0';
            count++;
            p = end + 1;
        } else {
            break;
        }
    }
    return count;
}

int parseValues(const char* line, int values[][2]) {
    int count = 0;
    const char* p = line;
    while ((p = strchr(p, '[')) != NULL) {
        p++; // Skip opening bracket
        const char* end = strchr(p, ']');
        if (end != NULL) {
            char arrStr[100];
            int len = end - p;
            strncpy(arrStr, p, len);
            arrStr[len] = '\0';
            
            if (strlen(arrStr) > 0 && arrStr[0] != '\0') {
                // Parse numbers in the array using strtol
                const char* str = arrStr;
                int size = 0;
                int arr[10];
                const char* ptr = str;
                while (*ptr && *ptr != ']') {
                    while (*ptr == ' ' || *ptr == ',') ptr++;
                    if (*ptr == ']' || *ptr == '\0') break;
                    arr[size++] = (int)strtol(ptr, (char**)&ptr, 10);
                }
                
                if (size >= 2) {
                    values[count][0] = arr[0];
                    values[count][1] = arr[1];
                }
            }
            count++;
            p = end + 1;
        } else {
            break;
        }
    }
    return count;
}

int main() {
    char line1[1000], line2[2000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    char operations[MAX_OPERATIONS][20];
    int values[MAX_OPERATIONS][2];
    
    int opCount = parseOperations(line1, operations);
    int valCount = parseValues(line2, values);
    
    MyCalendarThree* cal = myCalendarThreeCreate();
    int results[100];
    int resultCount = 0;
    
    for (int i = 0; i < opCount; i++) {
        if (strcmp(operations[i], "MyCalendarThree") == 0) {
            continue;
        } else {
            int start = values[i][0];
            int end = values[i][1];
            results[resultCount++] = myCalendarThreeBook(cal, start, end);
        }
    }
    
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        printf("%d", results[i]);
        if (i < resultCount - 1) printf(",");
    }
    printf("]\n");
    
    free(cal);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each booking, we check all previous bookings and scan time points

⚠ Quadratic Growth

Space Complexity

O(n)

Store all booking intervals in a list

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

856 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 with List Storage — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler