📚 Meeting Rooms II – Java Cheat Sheet (One Page)

📌 What Is It?

The Meeting Rooms II problem involves finding the minimum number of meeting rooms required to accommodate all meetings without overlap. Each meeting is represented as an interval with a start and end time.

Sort all intervals by start time
Use a min-heap (priority queue) to track ongoing meetings
Allocate or free meeting rooms dynamically

🧱 Pattern Template

public int minMeetingRooms(int[][] intervals) {
    if (intervals == null || intervals.length == 0) return 0;

    // Sort intervals by start time
    Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));

    // Min-heap to track end times of meetings
    PriorityQueue heap = new PriorityQueue<>();

    // Add the first meeting
    heap.add(intervals[0][1]);

    for (int i = 1; i < intervals.length; i++) {
        // If the room due to free up the earliest is free, remove it
        if (intervals[i][0] >= heap.peek()) {
            heap.poll();
        }

        // Add the current meeting's end time to the heap
        heap.add(intervals[i][1]);
    }

    // The size of the heap is the number of meeting rooms required
    return heap.size();
}

✅ Use Cases

Scheduling meetings in conference rooms
Resource allocation problems
Handling overlapping intervals

📘 Common LeetCode Problems

253: Meeting Rooms II [Medium] Heap, Intervals
252: Meeting Rooms [Easy] Sorting, Intervals

🧪 Example: Meeting Rooms II

Input: intervals = [[0,30],[5,10],[15,20]]
Output: 2
Explanation: Two meeting rooms are required:
- Room 1: [0,30]
- Room 2: [5,10] and [15,20]

⏱ Time and Space Complexity

Time Complexity: O(n log n) - Sorting the intervals takes O(n log n). - Each insertion and removal operation in the min-heap takes O(log k), where k is the size of the heap. In the worst case, this is O(n log n).
Space Complexity: O(n) - The heap can grow to the size of all intervals in the worst case.

💡 Pro Tips

Use a min-heap to efficiently track the earliest ending meeting
Sort intervals by start time before processing
Edge cases: no meetings, all meetings overlap