LeetCode 252: Meeting Rooms Solution in Python – A Step-by-Step Guide

What Is LeetCode 252: Meeting Rooms?

In LeetCode 252: Meeting Rooms, you’re given a list of meeting time intervals, where each interval is a pair [start, end] representing the start and end times of a meeting. Your task is to check if a single meeting room can accommodate all meetings without any overlaps. This problem introduces interval scheduling, a concept related to challenges like LeetCode 253: Meeting Rooms II, but focuses on a simple yes-or-no answer.

Problem Statement

• Input: A list of intervals intervals, where each interval is [start, end].
• Output: A boolean—true if all meetings can fit in one room (no overlaps), false if any overlap occurs.
• Rules: An overlap happens if one meeting’s start time is before another’s end time and vice versa.

Constraints

• Number of intervals: 0 to 10^4.
• Start and end times: 0 to 10^6.
• start < end for each interval.

Examples

• Input: intervals = [[0,30], [5,10], [15,20]]
• Output: false (0-30 overlaps with 5-10).
• Input: intervals = [[7,10], [2,4]]
• Output: true (no overlaps).
• Input: intervals = []
• Output: true (empty list has no conflicts).

Understanding the Problem: Checking for Overlaps

To solve LeetCode 252: Meeting Rooms in Python, we need to determine if any two meetings overlap in a way that prevents them from sharing one room. Two intervals [s1, e1] and [s2, e2] overlap if one starts before the other ends (e.g., s1 < e2 and s2 < e1). A basic approach—comparing every pair—works but is slow. We’ll use two methods: 1. Best Solution (Sorting with Overlap Check): O(n log n) time—fast and smart. 2. Alternative Solution (Brute Force Comparison): O(n²) time—simple but inefficient.

Let’s dive into the best solution with extra detail for beginners.

Best Solution: Sorting with Overlap Check

Why This Is the Best Solution

The sorting with overlap check approach is the top choice for LeetCode 252 because it runs in O(n log n) time by sorting the intervals by start time and then checking adjacent pairs for overlaps. It’s efficient, easy to understand once you see it, and scales well, making it perfect for this problem.

How It Works

Imagine you’re lining up meetings on a timeline, like scheduling them on a calendar from earliest to latest. If you put them in order by when they start, you only need to check if each meeting ends before the next one begins. If any meeting runs past the start of the next, you’ve got a clash! Here’s how it works, step-by-step, explained simply for beginners:

• Step 1: Sort the Meetings:
• Take the list of intervals and sort them by their start times.
• For example, [[5,10], [0,30], [15,20]] becomes [[0,30], [5,10], [15,20]].
• Sorting puts meetings in chronological order, so we can check them one after another.
• Step 2: Check for Overlaps:
• Walk through the sorted list, looking at each pair of neighbors (like [0,30] and [5,10]).
• For two meetings [s1, e1] and [s2, e2] where s1 ≤ s2 (because we sorted):
• If e1 > s2, the first meeting hasn’t ended when the second starts—they overlap!
• If e1 ≤ s2, the first ends before the second begins—no overlap.
• If any pair overlaps, we can stop and say “No, one room isn’t enough.”
• Step 3: Handle Edge Cases:
• If the list is empty or has one meeting, there’s no overlap possible—return true.
• Step 4: Conclusion:
• If you get through all pairs without finding an overlap, return true—one room works!

It’s like lining up kids for a race: if one kid’s finish line crosses the next kid’s starting line, they bump into each other. Sorting makes it easy to spot those bumps!

Step-by-Step Example

Example: intervals = [[0,30], [5,10], [15,20]]

• Step 1: Sort by Start Time:
• Original: [[0,30], [5,10], [15,20]].
• Sorted: [[0,30], [5,10], [15,20]] (already in order).
• Step 2: Check Adjacent Pairs:
• Pair 1: [0,30] and [5,10]:
• s1 = 0, e1 = 30, s2 = 5, e2 = 10.
• Check: e1 = 30 > s2 = 5? Yes, they overlap (0-30 runs past 5).
• Stop here—no need to check further, return false.
• Result: false (overlaps exist).

Example: intervals = [[7,10], [2,4]]

• Step 1: Sort by Start Time:
• Original: [[7,10], [2,4]].
• Sorted: [[2,4], [7,10]].
• Step 2: Check Adjacent Pairs:
• Pair 1: [2,4] and [7,10]:
• s1 = 2, e1 = 4, s2 = 7, e2 = 10.
• Check: e1 = 4 > s2 = 7? No, 4 ≤ 7—no overlap.
• Step 3: Only One Pair:
• No more pairs to check, no overlaps found.
• Result: true (no overlaps).

Code with Detailed Line-by-Line Explanation

Here’s the Python code, explained step-by-step for beginners:

Copy codeclass Solution:
    def canAttendMeetings(self, intervals: List[List[int]]) -> bool:
        # Step 1: Handle empty or single meeting cases
        if not intervals or len(intervals) == 1:
            return True  # No overlaps possible

        # Step 2: Sort intervals by start time
        # We use lambda to tell Python to look at the first number (start time)
        intervals.sort(key=lambda x: x[0])

        # Step 3: Check each pair of neighbors
        for i in range(1, len(intervals)):
            # Get the previous meeting’s end time
            prev_end = intervals[i-1][1]
            # Get the current meeting’s start time
            curr_start = intervals[i][0]

            # Step 4: Do they overlap?
            if prev_end > curr_start:
                # If previous meeting ends after current starts, they clash
                return False

        # Step 5: No overlaps found!
        return True

• Time Complexity: O(n log n)—sorting dominates.
• Space Complexity: O(1)—no extra space beyond sorting (in-place in Python).

This solution is like a tidy calendar check—sort it, scan it, and you’re done!

Alternative Solution: Brute Force Comparison

Why an Alternative Approach?

The brute force comparison approach checks every possible pair of meetings to see if any overlap. It’s not the fastest, but it’s super straightforward—like manually flipping through a schedule to spot conflicts. It’s great for beginners to see the problem’s core idea before moving to the optimized solution.

How It Works

Imagine you’re comparing every meeting with every other meeting, like holding up two pieces of paper to see if their time blocks overlap. For each pair, you check if one starts before the other ends. Here’s how it works, explained simply:

• Step 1: Look at All Pairs:
• Take every meeting and compare it with every other meeting.
• For [s1, e1] and [s2, e2], they overlap if s1 < e2 and s2 < e1.
• Step 2: Check Overlap:
• If any pair overlaps, return false—one room won’t work.
• Step 3: No Overlaps:
• If you check all pairs and find no overlaps, return true.

It’s like double-checking every friend’s party invite to make sure no one’s double-booked!

Step-by-Step Example

Example: intervals = [[0,30], [5,10], [15,20]]

• Pairs to Check:
• [0,30] vs [5,10]:
• s1 = 0 < e2 = 10? Yes.
• s2 = 5 < e1 = 30? Yes.
• Overlap! Return false.
• Stop: No need to check further.
• Result: false.

Example: intervals = [[7,10], [2,4]]

• Pairs:
• [7,10] vs [2,4]:
• s1 = 7 < e2 = 4? No (7 > 4).
• s2 = 2 < e1 = 10? Yes, but first condition fails—no overlap.
• Result: true.

Code for Brute Force Approach

Copy codeclass Solution:
    def canAttendMeetings(self, intervals: List[List[int]]) -> bool:
        # Step 1: Handle empty or single case
        if not intervals or len(intervals) == 1:
            return True

        # Step 2: Check every pair
        for i in range(len(intervals)):
            for j in range(i + 1, len(intervals)):
                # Get the two meetings
                s1, e1 = intervals[i]
                s2, e2 = intervals[j]

                # Step 3: Do they overlap?
                if s1 < e2 and s2 < e1:
                    return False

        # Step 4: No overlaps found
        return True

• Time Complexity: O(n²)—checking all pairs.
• Space Complexity: O(1)—no extra space.

It’s slow but shows the idea clearly.

Comparing the Two Solutions

• Best Solution (Sorting):
• Pros: O(n log n) time, efficient, scalable.
• Cons: Requires sorting concept.
• Alternative Solution (Brute Force):
• Pros: Simple, no sorting needed.
• Cons: O(n²) time, slow for big lists.

Sorting wins for speed.

Additional Examples and Edge Cases

Empty List

• [] → true

Single Meeting

• [[1,2]] → true

Touching Intervals

• [[1,2], [2,3]] → true (no overlap, end = start).

Both handle these well.

Complexity Breakdown

• Sorting:
• Time: O(n log n)—sorting step.
• Space: O(1)—in-place.
• Brute Force:
• Time: O(n²)—all pairs.
• Space: O(1)—minimal.

Sorting is faster.

Key Takeaways for Beginners

• Sorting: Order makes checking easy.
• Overlap: Check if one ends after another starts.
• Brute Force: Compare everything—good first step.
• Python Tip: Sorting is simple with sort()—see [Python Basics](/python/basics).

Final Thoughts: Schedule Like a Pro

LeetCode 252: Meeting Rooms in Python is a great intro to interval problems. The sorting solution offers O(n log n) efficiency, while brute force provides a clear starting point. Want more? Try LeetCode 253: Meeting Rooms II or LeetCode 435: Non-overlapping Intervals. Ready to schedule? Head to Solve LeetCode 252 on LeetCode and check those meetings today!