Meeting Rooms III - Practice Coding Problems

Meeting Rooms III - Problem

Imagine you're managing a busy conference center with n meeting rooms numbered from 0 to n-1. Throughout the day, you receive a list of meeting requests, each with a specific start and end time.

You are given a 2D integer array meetings where meetings[i] = [start_i, end_i] represents a meeting that needs the time interval [start_i, end_i) (half-closed interval - includes start time but excludes end time).

Room Allocation Rules:

🏢 Each meeting gets assigned to the lowest-numbered available room
⏰ If no rooms are free, the meeting is delayed until a room becomes available (keeping the same duration)
📅 When multiple meetings are waiting, priority goes to the meeting with the earliest original start time

Goal: Return the room number that hosted the most meetings. If there's a tie, return the lowest-numbered room.

Input & Output

example_1.py — Basic Room Assignment

$ Input: n = 2, meetings = [[0,10],[1,5],[2,7],[3,4]]

› Output: 0

💡 Note: Room 0: meetings [0,10), [1,5) (delayed to [10,15)), [2,7) (delayed to [15,20)), [3,4) (delayed to [20,21)) - 4 meetings. Room 1: no meetings. Room 0 has the most meetings.

example_2.py — Multiple Rooms Used

$ Input: n = 3, meetings = [[1,20],[2,10],[3,5],[4,9],[6,8]]

› Output: 1

💡 Note: Room 0 gets [1,20). Room 1 gets [2,10), [4,9) (delayed to [10,15)), [6,8) (delayed to [15,17)) - 3 meetings. Room 2 gets [3,5). Room 1 has the most meetings.

example_3.py — Tie Breaking

$ Input: n = 4, meetings = [[18,19],[3,12],[17,19],[2,13]]

› Output: 0

💡 Note: After sorting by start time: [2,13), [3,12), [17,19), [18,19). Each room gets 1 meeting, so return room 0 (lowest number).

Constraints

1 ≤ n ≤ 100
1 ≤ meetings.length ≤ 10⁵
meetings[i].length == 2
0 ≤ start_i < end_i ≤ 5 × 10⁵
All start times are unique

Visualization

Tap to expand

Understanding the Visualization

Sort Meetings

Process meetings in chronological order by start time

Track Availability

Use min-heap to always get the lowest available room number

Handle Conflicts

When all rooms busy, delay meeting using earliest finishing room

Count and Compare

Track meetings per room, return room with maximum count

Key Takeaway

🎯 Key Insight: Priority queues provide O(log n) efficient room management, making this scheduling problem tractable even for large inputs by maintaining optimal room assignment order.

Asked in

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

The optimal solution uses two priority queues: one for available rooms (min-heap by room number) and one for occupied rooms (min-heap by end time). This achieves O(m log n) time complexity by efficiently tracking room availability and scheduling meetings with proper delay handling.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n² × m)	O(n × m)	Simulate each meeting assignment by checking all rooms manually
Priority Queue + Simulation (Optimal)	O(m log n)	O(n)	Use two priority queues to efficiently track available and occupied rooms

Brute Force Simulation — Algorithm Steps

Sort meetings by start time
For each meeting, check every room for availability
Find the lowest-numbered free room
If no room is free, delay the meeting until the earliest room becomes available
Track meeting count per room
Return room with maximum meetings

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Meetings

Sort meetings by start time

Check Each Room

For each meeting, scan all rooms sequentially

Find Available Room

Assign to lowest numbered available room

Handle Delays

If no room available, delay meeting

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    int *arr1 = *(int**)a;
    int *arr2 = *(int**)b;
    return arr1[0] - arr2[0];
}

int mostBooked(int n, int** meetings, int meetingsSize, int* meetingsColSize) {
    qsort(meetings, meetingsSize, sizeof(int*), compare);
    
    int *roomMeetings = calloc(n, sizeof(int));
    long long *roomEndTimes = calloc(n, sizeof(long long));
    
    for (int i = 0; i < meetingsSize; i++) {
        long long start = meetings[i][0], end = meetings[i][1];
        long long duration = end - start;
        long long earliestFreeTime = LLONG_MAX;
        int bestRoom = -1;
        
        for (int room = 0; room < n; room++) {
            if (roomEndTimes[room] <= start) {
                bestRoom = room;
                break;
            } else if (roomEndTimes[room] < earliestFreeTime) {
                earliestFreeTime = roomEndTimes[room];
                bestRoom = room;
            }
        }
        
        if (roomEndTimes[bestRoom] <= start) {
            roomEndTimes[bestRoom] = end;
        } else {
            roomEndTimes[bestRoom] += duration;
        }
        
        roomMeetings[bestRoom]++;
    }
    
    int maxMeetings = 0, result = 0;
    for (int i = 0; i < n; i++) {
        if (roomMeetings[i] > maxMeetings) {
            maxMeetings = roomMeetings[i];
            result = i;
        }
    }
    
    free(roomMeetings);
    free(roomEndTimes);
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

For each of n meetings, we might check all m rooms and scan through all previous meetings

⚠ Quadratic Growth

Space Complexity

O(n × m)

Store meeting assignments for each room

⚡ Linearithmic Space

28.4K Views

High Frequency

~25 min Avg. Time

890 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler