Why Meeting Rooms Problem Minimum Rooms Required in DSA Typescript?

The Big Idea

What if you could instantly know the exact number of rooms needed for any meeting schedule without guessing?

The Scenario

Imagine you are organizing meetings in a small office with limited rooms. You have a list of meeting times, and you need to decide how many rooms to prepare. Doing this by checking each meeting against every other meeting manually is like trying to juggle many balls at once--it quickly becomes confusing and overwhelming.

The Problem

Manually comparing every meeting time with all others takes a lot of time and is easy to mess up. You might forget to check some overlaps or count rooms twice. This slow and error-prone process makes planning stressful and inefficient.

The Solution

The Meeting Rooms Problem solution uses sorting and smart tracking to quickly find the minimum number of rooms needed. By sorting meetings by start time and using a simple structure to track ongoing meetings, it finds overlaps easily without checking every pair manually.

Before vs After

✗ Before

for (let i = 0; i < meetings.length; i++) {
  for (let j = i + 1; j < meetings.length; j++) {
    if (meetings[i].overlaps(meetings[j])) {
      rooms++;
    }
  }
}

✓ After

meetings.sort((a, b) => a.start - b.start);
const rooms = [];
for (const meeting of meetings) {
  if (rooms.length > 0 && rooms[0] <= meeting.start) rooms.shift();
  rooms.push(meeting.end);
  rooms.sort((a, b) => a - b);
}
return rooms.length;

What It Enables

This method lets you quickly and reliably find the minimum number of rooms needed for any schedule, no matter how many meetings there are.

Real Life Example

Think about a conference center with many talks happening at once. Using this approach, organizers can know exactly how many rooms to prepare so no talk overlaps in the same room.

Key Takeaways

Manual checking of meeting overlaps is slow and error-prone.

Sorting meetings by start time helps organize the problem.

Tracking ongoing meetings with a simple list finds minimum rooms efficiently.

Practice

1. What does the "Meeting Rooms Problem Minimum Rooms Required" ask you to find given a list of meeting time intervals?

easy

A. The maximum duration of a single meeting

B. The minimum number of meeting rooms needed to hold all meetings without overlap

C. The total number of meetings scheduled

D. The earliest start time among all meetings

Solution

1. Step 1: Understand the problem goal

   The problem asks for the minimum number of rooms needed so that no meetings overlap in the same room.

2. Step 2: Clarify what is NOT asked

   It is not about meeting durations, counts, or earliest times, but about room allocation to avoid conflicts.

3. Final Answer:

   The minimum number of meeting rooms needed to hold all meetings without overlap -> Option B

4. Quick Check:

   Minimum rooms = no overlapping meetings [OK]

Hint: Count overlaps to find minimum rooms needed [OK]

Common Mistakes:

• Confusing total meetings with rooms needed
• Thinking about meeting length instead of overlaps
• Ignoring overlapping intervals

2. Which TypeScript code snippet correctly sorts an array of meeting intervals by their start time?

easy

A. intervals.sort((a, b) => a[0] + b[0]);

B. intervals.sort((a, b) => b[1] - a[1]);

C. intervals.sort((a, b) => a[1] - b[0]);

D. intervals.sort((a, b) => a[0] - b[0]);

Solution

1. Step 1: Identify sorting by start time

   We want to sort intervals by their start time, which is the first element in each interval array.

2. Step 2: Check the sorting function

   The correct comparator subtracts start times: a[0] - b[0]. This sorts ascending by start time.

3. Final Answer:

   intervals.sort((a, b) => a[0] - b[0]); -> Option D

4. Quick Check:

   Sort by start time = a[0] - b[0] [OK]

Hint: Sort intervals by start time using a[0] - b[0] [OK]

Common Mistakes:

• Sorting by end time instead of start time
• Using addition instead of subtraction in comparator
• Mixing start and end indices in comparator

3. Given the following TypeScript code, what is the output?

const intervals = [[0, 30], [5, 10], [15, 20]];

function minMeetingRooms(intervals: number[][]): number {
  intervals.sort((a, b) => a[0] - b[0]);
  const heap: number[] = [];

  for (const interval of intervals) {
    if (heap.length && heap[0] <= interval[0]) {
      heap.shift();
    }
    heap.push(interval[1]);
    heap.sort((a, b) => a - b);
  }

  return heap.length;
}

console.log(minMeetingRooms(intervals));

medium

A. 2

B. 3

C. 1

D. 0

Solution

1. Step 1: Sort intervals by start time

   Sorted intervals: [[0,30], [5,10], [15,20]] (already sorted)

2. Step 2: Simulate heap to track end times

   First interval: heap = [30] Second interval starts at 5, heap[0]=30 > 5, so no removal, heap = [30,10], sorted to [10,30] Third interval starts at 15, heap[0]=10 <= 15, remove 10, heap = [30], then add 20, heap = [20,30]

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Max overlapping meetings = 2 rooms needed [OK]

Hint: Track earliest end time to reuse rooms [OK]

Common Mistakes:

• Not sorting intervals before processing
• Not removing ended meetings from heap
• Assuming heap length equals total meetings

4. The following TypeScript code is intended to find the minimum number of meeting rooms needed. What is the bug?

function minMeetingRooms(intervals: number[][]): number {
  intervals.sort((a, b) => a[1] - b[1]);
  const heap: number[] = [];

  for (const interval of intervals) {
    if (heap.length && heap[0] <= interval[0]) {
      heap.shift();
    }
    heap.push(interval[1]);
    heap.sort((a, b) => a - b);
  }

  return heap.length;
}

medium

A. Intervals are sorted by end time instead of start time

B. Heap is not sorted after push

C. The condition to remove from heap is incorrect

D. The function returns the wrong value

Solution

1. Step 1: Check sorting criteria

   The intervals are sorted by end time (a[1] - b[1]) but should be sorted by start time to process meetings in order.

2. Step 2: Understand impact of wrong sorting

   Sorting by end time breaks the logic of checking overlaps because meetings are not processed in chronological start order.

3. Final Answer:

   Intervals are sorted by end time instead of start time -> Option A

4. Quick Check:

   Sort by start time, not end time [OK]

Hint: Always sort intervals by start time first [OK]

Common Mistakes:

• Sorting by end time instead of start time
• Not sorting heap after insertion
• Incorrect condition to remove ended meetings

5. You have the following meeting intervals: [[1,4], [2,5], [7,9], [3,6], [10,11]]. What is the minimum number of meeting rooms required to schedule all meetings without overlap?

hard

A. 4

B. 2

C. 3

D. 1

Solution

1. Step 1: Sort intervals by start time

   Sorted intervals: [[1,4], [2,5], [3,6], [7,9], [10,11]]

2. Step 2: Track overlapping meetings

   At time 1: room count = 1 At time 2: overlaps with [1,4], rooms = 2 At time 3: overlaps with [1,4] and [2,5], rooms = 3 At time 7: previous meetings ended, rooms = 1 At time 10: rooms = 1

3. Final Answer:

   3 -> Option C

4. Quick Check:

   Max overlaps = 3 rooms needed [OK]

Hint: Count max overlaps at any time for rooms needed [OK]

Common Mistakes:

• Not sorting intervals before counting overlaps
• Underestimating overlaps by ignoring simultaneous meetings
• Assuming one room fits all meetings