Seat Reservation Manager

Seat Reservation Manager - Problem

Design a system that manages the reservation state of n seats that are numbered from 1 to n.

Implement the SeatManager class:

SeatManager(int n) Initializes a SeatManager object that will manage n seats numbered from 1 to n. All seats are initially available.
int reserve() Fetches the smallest-numbered unreserved seat, reserves it, and returns its number.
void unreserve(int seatNumber) Unreserves the seat with the given seatNumber.

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["SeatManager", "reserve", "reserve", "unreserve", "reserve"], values = [[5], [], [], [2], []]

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

💡 Note: Initialize with 5 seats (1-5 available). reserve() returns 1 (smallest). reserve() returns 2. unreserve(2) makes seat 2 available. reserve() returns 2 (seat 2 is the smallest available since seat 1 is still reserved).

Example 2 — Multiple Unreserve

$ Input: operations = ["SeatManager", "reserve", "reserve", "unreserve", "unreserve", "reserve"], values = [[3], [], [], [1], [2], []]

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

💡 Note: Initialize with 3 seats. Reserve seats 1 and 2. Unreserve both seats 1 and 2. Next reserve() returns 1 (smaller than 2).

Example 3 — Edge Case with Single Seat

$ Input: operations = ["SeatManager", "reserve", "unreserve", "reserve"], values = [[1], [], [1], []]

› Output: [null, 1, null, 1]

💡 Note: Only 1 seat available. Reserve it (returns 1), unreserve it, reserve again (returns 1).

Constraints

1 ≤ n ≤ 10⁵
1 ≤ seatNumber ≤ n
At most 10⁵ calls will be made to reserve and unreserve

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 8 M Microsoft 6

The key insight is to use a min-heap to maintain available seats in sorted order. The min-heap always keeps the smallest available seat at the root, allowing O(log n) access for both reserve() and unreserve() operations. Best approach is Min-Heap with Time: O(log n), Space: O(n).

Common Approaches

✓ Brute Force with Boolean Array

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

Maintain a boolean array where each index represents seat availability. For reserve(), scan from seat 1 until finding the first unreserved seat. For unreserve(), simply mark the seat as available.

Min-Heap (Priority Queue)

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

Maintain a min-heap containing all available seat numbers. The heap's root always contains the smallest available seat. For reserve(), extract the minimum. For unreserve(), add the seat back to the heap.

Brute Force with Boolean Array — Algorithm Steps

Step 1: Create boolean array of size n+1 (1-indexed)
Step 2: For reserve(), scan array from index 1 to find first false
Step 3: For unreserve(), set array[seatNumber] = false

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create boolean array with all seats available (false)

Reserve

Scan from seat 1 until finding first false, mark as true

Unreserve

Directly mark specified seat as false

Code -

solution.c — C

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

typedef struct {
    bool* seats;
    int n;
} SeatManager;

SeatManager* seatManagerCreate(int n) {
    SeatManager* obj = (SeatManager*)malloc(sizeof(SeatManager));
    obj->seats = (bool*)calloc(n + 1, sizeof(bool));
    obj->n = n;
    return obj;
}

int seatManagerReserve(SeatManager* obj) {
    for (int i = 1; i <= obj->n; i++) {
        if (!obj->seats[i]) {
            obj->seats[i] = true;
            return i;
        }
    }
    return -1;
}

void seatManagerUnreserve(SeatManager* obj, int seatNumber) {
    obj->seats[seatNumber] = false;
}

void seatManagerFree(SeatManager* obj) {
    free(obj->seats);
    free(obj);
}

static int results[1000];
static int result_count = 0;

int main() {
    char operations[2000], values[2000];
    fgets(operations, sizeof(operations), stdin);
    fgets(values, sizeof(values), stdin);
    
    // Remove newlines
    operations[strcspn(operations, "\n")] = 0;
    values[strcspn(values, "\n")] = 0;
    
    SeatManager* seat_manager = NULL;
    result_count = 0;
    
    char* op_ptr = operations;
    char* val_ptr = values;
    
    // Skip to first quote in operations
    while (*op_ptr && *op_ptr != '"') op_ptr++;
    
    // Skip to first bracket in values  
    while (*val_ptr && *val_ptr != '[') val_ptr++;
    val_ptr++; // skip first '['
    
    while (*op_ptr) {
        if (*op_ptr == '"') {
            op_ptr++;
            if (strncmp(op_ptr, "SeatManager", 11) == 0) {
                // Find corresponding value
                while (*val_ptr && *val_ptr != '[') val_ptr++;
                if (*val_ptr == '[') {
                    val_ptr++;
                    if (*val_ptr != ']') {
                        int n = strtol(val_ptr, &val_ptr, 10);
                        seat_manager = seatManagerCreate(n);
                    }
                    while (*val_ptr && *val_ptr != ']') val_ptr++;
                    if (*val_ptr == ']') val_ptr++;
                }
                results[result_count++] = -1; // null placeholder
                op_ptr += 11;
            } else if (strncmp(op_ptr, "reserve", 7) == 0) {
                // Skip to corresponding empty array
                while (*val_ptr && *val_ptr != '[') val_ptr++;
                if (*val_ptr == '[') {
                    val_ptr++;
                    while (*val_ptr && *val_ptr != ']') val_ptr++;
                    if (*val_ptr == ']') val_ptr++;
                }
                int seat = seatManagerReserve(seat_manager);
                results[result_count++] = seat;
                op_ptr += 7;
            } else if (strncmp(op_ptr, "unreserve", 9) == 0) {
                // Find corresponding value
                while (*val_ptr && *val_ptr != '[') val_ptr++;
                if (*val_ptr == '[') {
                    val_ptr++;
                    int seat_num = strtol(val_ptr, &val_ptr, 10);
                    seatManagerUnreserve(seat_manager, seat_num);
                    while (*val_ptr && *val_ptr != ']') val_ptr++;
                    if (*val_ptr == ']') val_ptr++;
                }
                results[result_count++] = -1; // null placeholder
                op_ptr += 9;
            }
        } else {
            op_ptr++;
        }
    }
    
    // Print results
    printf("[");
    for (int i = 0; i < result_count; i++) {
        if (i > 0) printf(",");
        if (results[i] == -1) {
            printf("null");
        } else {
            printf("%d", results[i]);
        }
    }
    printf("]\n");
    
    if (seat_manager) {
        seatManagerFree(seat_manager);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each reserve() operation scans up to n seats to find the first available

✓ Linear Growth

Space Complexity

O(n)

Boolean array of size n to track seat availability

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

892 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 Boolean Array — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler