Seat Reservation Manager - Practice Coding Problems

Seat Reservation Manager - Problem

You're tasked with designing a smart seating system for a modern theater or event venue. The system manages n seats numbered from 1 to n, and must efficiently handle two main operations:

Reserve a seat: Always assign the lowest-numbered available seat to maintain optimal seating arrangement
Cancel a reservation: Free up a specific seat so it becomes available again

Your SeatManager class should implement:

SeatManager(int n) - Initialize the system with n seats (all initially available)
int reserve() - Find and reserve the smallest-numbered unreserved seat, return its number
void unreserve(int seatNumber) - Make the specified seat available again

Goal: Design an efficient system that can handle thousands of reservations and cancellations while always maintaining the "lowest available seat first" policy.

Input & Output

example_1.py — Basic Operations

$ Input: SeatManager(5) reserve() → 1 reserve() → 2 unreserve(2) reserve() → 2

› Output: 1 2 2

💡 Note: Initialize with 5 seats. First reserve() returns seat 1, second returns seat 2. After unreserving seat 2, next reserve() returns seat 2 again (lowest available).

example_2.py — Multiple Unreservations

$ Input: SeatManager(3) reserve() → 1 reserve() → 2 reserve() → 3 unreserve(1) unreserve(3) reserve() → 1

› Output: 1 2 3 1

💡 Note: Reserve all 3 seats, then unreserve seats 1 and 3. Next reserve() returns seat 1 (smaller than seat 3).

example_3.py — Large Venue

$ Input: SeatManager(100000) reserve() → 1 unreserve(1) reserve() → 1

› Output: 1 1

💡 Note: Even with 100,000 seats, operations remain efficient. Reserve seat 1, unreserve it, then reserve again gets seat 1.

Visualization

Tap to expand

Understanding the Visualization

Setup

Initialize with all seats available in min-heap

Customer Arrives

Extract minimum seat number from heap top

Cancellation

Add returned seat back to heap

Next Customer

Heap automatically provides next lowest seat

Key Takeaway

🎯 Key Insight: Min-heap provides the perfect balance of efficiency and simplicity, automatically maintaining the "smallest available first" property while delivering O(log n) performance for both operations.

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Heap operations (extract-min and insert) both take O(log n) time

⚡ Linearithmic

Space Complexity

O(n)

Heap stores all available seats, up to n seats in worst case

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁵
1 ≤ seatNumber ≤ n
For each call to reserve(), it is guaranteed that there will be at least one unreserved seat
For each call to unreserve(), it is guaranteed that seatNumber will be reserved
At most 10⁵ calls in total will be made to reserve() and unreserve()

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses a min-heap (priority queue) to maintain available seats. This ensures O(log n) time complexity for both reserve() and unreserve() operations, making it highly scalable for large venues with thousands of seats. The heap naturally keeps the smallest available seat at the root, perfect for the "lowest seat first" requirement.

Common Approaches

Approach	Time	Space	Notes
✓ Linear Search Approach	O(n)	O(n)	Check seats sequentially from 1 to n to find the first available
Min-Heap (Priority Queue) - Optimal	O(log n)	O(n)	Use a min-heap to always get the smallest available seat in O(log n) time

Linear Search Approach — Algorithm Steps

Initialize boolean array with all seats available (false)
For reserve(): scan from seat 1 until finding first available seat
Mark found seat as reserved and return its number
For unreserve(): simply mark the seat as available again

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

All seats start as available (green)

Reserve

Scan from seat 1 until finding first available

Mark Reserved

Mark found seat as reserved (red)

Code -

solution.c — C

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

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

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

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

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

void seatManagerFree(SeatManager* sm) {
    free(sm->reserved);
    free(sm);
}

int main() {
    SeatManager* sm = seatManagerCreate(5);
    printf("%d\n", seatManagerReserve(sm)); // 1
    printf("%d\n", seatManagerReserve(sm)); // 2
    seatManagerUnreserve(sm, 1);
    printf("%d\n", seatManagerReserve(sm)); // 1
    seatManagerFree(sm);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

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

✓ Linear Growth

Space Complexity

O(n)

Boolean array to track n seats' availability status

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁵
1 ≤ seatNumber ≤ n
For each call to reserve(), it is guaranteed that there will be at least one unreserved seat
For each call to unreserve(), it is guaranteed that seatNumber will be reserved
At most 10⁵ calls in total will be made to reserve() and unreserve()

52.0K Views

Medium Frequency

~15 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Linear Search Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler