Meeting Rooms III - Practice Coding Problems

Meeting Rooms III - Problem

You are given an integer n. There are n rooms numbered from 0 to n - 1.

You are given a 2D integer array meetings where meetings[i] = [starti, endi] means that a meeting will be held during the half-closed time interval [starti, endi). All the values of starti are unique.

Meetings are allocated to rooms in the following manner:

Each meeting will take place in the unused room with the lowest number.
If there are no available rooms, the meeting will be delayed until a room becomes free. The delayed meeting should have the same duration as the original meeting.
When a room becomes unused, meetings that have an earlier original start time should be given the room.

Return the number of the room that held the most meetings. If there are multiple rooms, return the room with the lowest number.

Input & Output

Example 1 — Basic Case

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

› Output: 0

💡 Note: Room 0: gets [0,10], [2,7] (delayed to [10,17]), [3,4] (delayed to [17,18]) = 3 meetings. Room 1: gets [1,5] = 1 meeting. Room 0 has most meetings.

Example 2 — Equal Distribution

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

› Output: 0

💡 Note: Room 0: [1,20], [6,8] (delayed to [20,22]) = 2 meetings. Room 1: [2,10], [4,9] (delayed to [10,15]) = 2 meetings. Room 2: [3,5] = 1 meeting. Tie between rooms 0 and 1, return lowest number 0.

Example 3 — Single Room

$ Input: n = 1, meetings = [[1,5],[2,3],[4,6]]

› Output: 0

💡 Note: Only room 0: gets [1,5], [2,3] (delayed to [5,6]), [4,6] (delayed to [6,8]) = 3 meetings. Room 0 is the only choice.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Input

n=2 rooms, meetings=[[0,10],[1,5],[2,7],[3,4]]

Process

Schedule to lowest available room, delay if all busy

Output

Room 0 holds most meetings (3), return 0

Key Takeaway

🎯 Key Insight: Use priority queues to efficiently track available and occupied rooms, avoiding O(n) scans for each meeting

Asked in

G Google 15 a Amazon 12 M Microsoft 8 🍎 Apple 6

The key insight is to use two priority queues: one for available rooms (min-heap by room number) and one for occupied rooms (min-heap by end time). This allows efficient O(log n) room assignment instead of O(n) scanning. Best approach is the Priority Queue Solution with Time: O(m log n), Space: O(n).

Common Approaches

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

Brute Force Simulation — Algorithm Steps

Sort meetings by start time
For each meeting, check all rooms for availability
If no room available, find earliest end time and delay meeting
Track meeting count per room

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Meetings

Sort meetings by start time

Check All Rooms

For each meeting, scan all rooms to find available one

Assign & Count

Assign to best room and increment counter

Code -

solution.c — C

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

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

int solution(int n, int** meetings, int meetingsSize) {
    qsort(meetings, meetingsSize, sizeof(int*), compare);
    
    long long* roomEndTime = (long long*)calloc(n, sizeof(long long));
    int* roomCount = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < meetingsSize; i++) {
        int start = meetings[i][0];
        int end = meetings[i][1];
        int duration = end - start;
        
        int bestRoom = -1;
        long long earliestAvailable = LLONG_MAX;
        
        for (int room = 0; room < n; room++) {
            if (roomEndTime[room] <= start) {
                bestRoom = room;
                break;
            } else {
                if (roomEndTime[room] < earliestAvailable) {
                    earliestAvailable = roomEndTime[room];
                    bestRoom = room;
                }
            }
        }
        
        if (roomEndTime[bestRoom] <= start) {
            roomEndTime[bestRoom] = end;
        } else {
            roomEndTime[bestRoom] = roomEndTime[bestRoom] + duration;
        }
        
        roomCount[bestRoom]++;
    }
    
    int maxMeetings = 0;
    for (int i = 0; i < n; i++) {
        if (roomCount[i] > maxMeetings) {
            maxMeetings = roomCount[i];
        }
    }
    
    for (int room = 0; room < n; room++) {
        if (roomCount[room] == maxMeetings) {
            free(roomEndTime);
            free(roomCount);
            return room;
        }
    }
    
    free(roomEndTime);
    free(roomCount);
    return 0;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char buffer[10000];
    scanf(" %s", buffer);
    
    // Simple parsing for 2D array
    int** meetings = (int**)malloc(1000 * sizeof(int*));
    int meetingsSize = 0;
    
    // Basic parsing - assumes format like [[1,2],[3,4]]
    char* ptr = buffer + 1; // Skip first '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            int* meeting = (int*)malloc(2 * sizeof(int));
            meeting[0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            if (*ptr == ',') ptr++;
            meeting[1] = atoi(ptr);
            while (*ptr && *ptr != ']') ptr++;
            if (*ptr == ']') ptr++;
            if (*ptr == ',') ptr++;
            meetings[meetingsSize++] = meeting;
        } else {
            ptr++;
        }
    }
    
    int result = solution(n, meetings, meetingsSize);
    printf("%d\n", result);
    
    // Free memory
    for (int i = 0; i < meetingsSize; i++) {
        free(meetings[i]);
    }
    free(meetings);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m² × n)

For each of m meetings, we check all n rooms, and may need to scan all meetings again to find delays

✓ Linear Growth

Space Complexity

O(n)

Store end times and meeting counts for n rooms

⚡ Linearithmic Space

23.4K Views

Medium Frequency

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

Visualization

Code -

Time & Space Complexity

Select Compiler