The Number of the Smallest Unoccupied Chair

The Number of the Smallest Unoccupied Chair - Problem

Imagine hosting a party where n friends (numbered 0 to n-1) arrive and leave at different times! The venue has an infinite number of chairs numbered from 0 to infinity, and there's one simple rule: when a friend arrives, they must sit in the lowest-numbered available chair.

Here's how it works:

If chairs 0, 1, and 5 are occupied when someone arrives, they'll sit in chair 2
When a friend leaves, their chair becomes available immediately
If someone leaves and another person arrives at the exact same moment, the arriving person can take that chair

You're given a 2D array times where times[i] = [arrival_i, leaving_i] represents when friend i arrives and leaves. Your mission: find which chair number the targetFriend will sit on!

Note: All arrival times are distinct, so no two friends arrive simultaneously.

Input & Output

example_1.py — Basic Party Scenario

$ Input: times = [[1,4],[2,3],[5,5]], targetFriend = 1

› Output: 1

💡 Note: Friend 0 arrives at time 1 and sits in chair 0. Friend 1 arrives at time 2 and sits in chair 1. Friend 1 leaves at time 3. Friend 2 arrives at time 5 and sits in chair 0 (now available). Since we want targetFriend = 1, the answer is chair 1.

example_2.py — Quick Turnaround

$ Input: times = [[3,10],[1,5],[2,6]], targetFriend = 0

› Output: 2

💡 Note: Friend 1 arrives at time 1 → chair 0. Friend 2 arrives at time 2 → chair 1. Friend 0 arrives at time 3 → chair 2. Since targetFriend = 0, the answer is chair 2.

example_3.py — Single Friend

$ Input: times = [[1,2]], targetFriend = 0

› Output: 0

💡 Note: Only one friend (friend 0) arrives at the party and gets the first available chair, which is chair 0.

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

All chairs 0, 1, 2... are available. Sort friends by arrival time.

First Arrival

Friend arrives at time T, gets chair 0 (smallest available). Add (departure_time, 0) to occupied heap.

Subsequent Arrivals

Check if anyone left by now. If yes, free their chairs. Assign smallest available chair.

Chair Recycling

When friends leave, their chairs become available for future arrivals.

Target Found

When target friend arrives, return their assigned chair number.

Key Takeaway

🎯 Key Insight: Use two min-heaps to efficiently track available chairs and departure events, ensuring O(log n) operations for chair assignment and departure processing.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n log n) for heap operations (each friend does at most 2 heap operations)

⚡ Linearithmic

Space Complexity

O(n)

O(n) space for heaps storing chairs and departure events

⚡ Linearithmic Space

Constraints

n == times.length
2 ≤ n ≤ 10⁴
times[i].length == 2
1 ≤ arrival_i < leaving_i ≤ 10⁵
0 ≤ targetFriend ≤ n - 1
All arrival times are distinct

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 15

The optimal solution uses two priority queues (heaps): one min-heap for available chairs and another for occupied chairs with departure times. Process friends in arrival order, freeing chairs when people leave and always assigning the smallest available chair. This achieves O(n log n) time complexity with efficient heap operations.

Common Approaches

Approach	Time	Space	Notes
✓ Event Processing with Priority Queues (Optimal)	O(n log n)	O(n)	Use two heaps: one for available chairs, one for departure events
Brute Force (Simulation with Array)	O(n²)	O(n)	Simulate the entire process using an array to track chair occupancy

Event Processing with Priority Queues (Optimal) — Algorithm Steps

Create events with friend indices and sort by arrival time
Initialize available chairs heap with chairs 0 to n-1
Initialize occupied chairs heap (departure_time, chair_number)
For each arrival, first process all departures at or before current time
Assign smallest available chair to current friend
If current friend is target, return their chair number

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Heaps

Available chairs: [0,1,2], Occupied chairs: []

Friend 0 Arrives

Assign chair 0, Available: [1,2], Occupied: [(4,0)]

Friend 1 Arrives

Assign chair 1, Available: [2], Occupied: [(3,1),(4,0)]

Friend 1 Leaves

Free chair 1, Available: [1,2], Occupied: [(4,0)]

Friend 2 Arrives

Assign chair 1 (smallest available)

Code -

solution.c — C

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

typedef struct {
    int arrival;
    int departure;
    int index;
} Friend;

typedef struct {
    int *data;
    int size;
    int capacity;
} Heap;

Heap* createHeap(int capacity) {
    Heap *h = (Heap*)malloc(sizeof(Heap));
    h->data = (int*)malloc(capacity * sizeof(int));
    h->size = 0;
    h->capacity = capacity;
    return h;
}

void heapifyUp(Heap *h, int idx) {
    while (idx > 0) {
        int parent = (idx - 1) / 2;
        if (h->data[idx] >= h->data[parent]) break;
        int temp = h->data[idx];
        h->data[idx] = h->data[parent];
        h->data[parent] = temp;
        idx = parent;
    }
}

void heapifyDown(Heap *h, int idx) {
    while (2 * idx + 1 < h->size) {
        int left = 2 * idx + 1;
        int right = 2 * idx + 2;
        int smallest = idx;
        
        if (h->data[left] < h->data[smallest]) {
            smallest = left;
        }
        if (right < h->size && h->data[right] < h->data[smallest]) {
            smallest = right;
        }
        
        if (smallest == idx) break;
        int temp = h->data[idx];
        h->data[idx] = h->data[smallest];
        h->data[smallest] = temp;
        idx = smallest;
    }
}

void push(Heap *h, int val) {
    h->data[h->size] = val;
    heapifyUp(h, h->size);
    h->size++;
}

int pop(Heap *h) {
    if (h->size == 0) return -1;
    int top = h->data[0];
    h->data[0] = h->data[h->size - 1];
    h->size--;
    if (h->size > 0) heapifyDown(h, 0);
    return top;
}

int compare(const void *a, const void *b) {
    Friend *friendA = (Friend *)a;
    Friend *friendB = (Friend *)b;
    return friendA->arrival - friendB->arrival;
}

int smallestChair(int** times, int timesSize, int targetFriend) {
    // Create events with original friend index
    Friend *friends = (Friend *)malloc(timesSize * sizeof(Friend));
    for (int i = 0; i < timesSize; i++) {
        friends[i].arrival = times[i][0];
        friends[i].departure = times[i][1];
        friends[i].index = i;
    }
    
    // Sort by arrival time
    qsort(friends, timesSize, sizeof(Friend), compare);
    
    // Available chairs heap
    Heap *availableChairs = createHeap(timesSize);
    for (int i = 0; i < timesSize; i++) {
        push(availableChairs, i);
    }
    
    // Simple array to track occupied chairs (simplified for basic implementation)
    int *occupiedTime = (int *)malloc(timesSize * sizeof(int));
    bool *isOccupied = (bool *)calloc(timesSize, sizeof(bool));
    
    for (int i = 0; i < timesSize; i++) {
        Friend currentFriend = friends[i];
        
        // Free chairs that should be available by now
        for (int j = 0; j < timesSize; j++) {
            if (isOccupied[j] && occupiedTime[j] <= currentFriend.arrival) {
                push(availableChairs, j);
                isOccupied[j] = false;
            }
        }
        
        // Assign smallest available chair
        int assignedChair = pop(availableChairs);
        
        // If this is our target friend, return their chair
        if (currentFriend.index == targetFriend) {
            free(friends);
            free(availableChairs->data);
            free(availableChairs);
            free(occupiedTime);
            free(isOccupied);
            return assignedChair;
        }
        
        // Mark chair as occupied until departure time
        isOccupied[assignedChair] = true;
        occupiedTime[assignedChair] = currentFriend.departure;
    }
    
    free(friends);
    free(availableChairs->data);
    free(availableChairs);
    free(occupiedTime);
    free(isOccupied);
    return -1;
}

int main() {
    int n, targetFriend;
    scanf("%d %d", &n, &targetFriend);
    int **times = (int **)malloc(n * sizeof(int *));
    for (int i = 0; i < n; i++) {
        times[i] = (int *)malloc(2 * sizeof(int));
        scanf("%d %d", &times[i][0], &times[i][1]);
    }
    printf("%d\n", smallestChair(times, n, targetFriend));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n log n) for heap operations (each friend does at most 2 heap operations)

⚡ Linearithmic

Space Complexity

O(n)

O(n) space for heaps storing chairs and departure events

⚡ Linearithmic Space

Constraints

n == times.length
2 ≤ n ≤ 10⁴
times[i].length == 2
1 ≤ arrival_i < leaving_i ≤ 10⁵
0 ≤ targetFriend ≤ n - 1
All arrival times are distinct

68.2K Views

Medium-High Frequency

~18 min Avg. Time

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

Event Processing with Priority Queues (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler