Meeting Rooms

Meeting Rooms - Problem

Array Sorting Easy

Given an array of meeting time intervals where intervals[i] = [start_i, end_i], determine if a person could attend all meetings.

A person can attend all meetings if no two meetings overlap. Two meetings overlap if one starts before the other ends.

Example: If you have meetings [[0,30], [5,10], [15,20]], you cannot attend all meetings because the first meeting [0,30] overlaps with both [5,10] and [15,20].

Input & Output

Example 1 — Overlapping Meetings

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

› Output: false

💡 Note: The first meeting [0,30] overlaps with both [5,10] and [15,20]. Since meeting [0,30] runs from time 0 to 30, it conflicts with meeting [5,10] which starts at time 5 (before 30 ends).

Example 2 — Non-overlapping Meetings

$ Input: intervals = [[7,10],[2,4]]

› Output: true

💡 Note: After sorting by start time: [2,4] then [7,10]. Meeting [2,4] ends at time 4, and [7,10] starts at time 7. Since 4 < 7, there's no overlap.

Example 3 — Adjacent Meetings

$ Input: intervals = [[1,3],[3,6],[6,8]]

› Output: true

💡 Note: Meetings end exactly when the next one starts: [1,3] ends at 3, [3,6] starts at 3. This is allowed - meetings can be back-to-back without overlap.

Constraints

0 ≤ intervals.length ≤ 10⁴
intervals[i].length == 2
0 ≤ start_i < end_i ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is that after sorting meetings by start time, only adjacent meetings can potentially overlap. The optimal approach sorts the intervals in O(n log n) time and then checks adjacent pairs in O(n), giving us O(n log n) time and O(1) space complexity.

Common Approaches

✓ Brute Force - Check All Pairs

⏱️ Time: O(n²) Space: O(1)

For each meeting, compare it with all other meetings to see if they overlap. Two meetings [a,b] and [c,d] overlap if max(a,c) < min(b,d).

Sort First - Optimal Solution

⏱️ Time: O(n log n) Space: O(1)

Sort the intervals by start time, then iterate through and check if any adjacent meetings overlap. If meetings are sorted by start time, only consecutive meetings can overlap.

Brute Force - Check All Pairs — Algorithm Steps

Iterate through each meeting
For each meeting, check it against all other meetings
If any pair overlaps, return false
If no overlaps found, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare All Pairs

Check each meeting against all others

Detect Overlap

Find if any two meetings conflict

Return Result

False if overlap found, true otherwise

Code -

solution.c — C

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

bool solution(int intervals[][2], int n) {
    // Check every pair of meetings for overlap
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            // Two intervals [a,b] and [c,d] overlap if max(a,c) < min(b,d)
            int maxStart = (intervals[i][0] > intervals[j][0]) ? intervals[i][0] : intervals[j][0];
            int minEnd = (intervals[i][1] < intervals[j][1]) ? intervals[i][1] : intervals[j][1];
            if (maxStart < minEnd) {
                return false;
            }
        }
    }
    return true;
}

void parseArray(const char* str, int intervals[][2], int* n) {
    *n = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',' || *p == '[') p++;
        if (*p == ']' || *p == '\0') break;
        
        intervals[*n][0] = (int)strtol(p, (char**)&p, 10);
        while (*p == ' ' || *p == ',') p++;
        intervals[*n][1] = (int)strtol(p, (char**)&p, 10);
        (*n)++;
        
        while (*p && *p != ']' && *p != '[') p++;
        if (*p == ']') p++;
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int intervals[100][2];
    int n = 0;
    parseArray(line, intervals, &n);
    
    bool result = solution(intervals, n);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops comparing each meeting with every other meeting

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra variables for iteration

✓ Linear Space

89.0K Views

High Frequency

~15 min Avg. Time

1.9K 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 - Check All Pairs — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler