Divide Intervals Into Minimum Number of Groups

Divide Intervals Into Minimum Number of Groups - Problem

Array Two Pointers Greedy Sorting Heap (Priority Queue) Prefix Sum Medium

Divide Intervals Into Minimum Number of Groups

You are given a 2D integer array intervals where intervals[i] = [left_i, right_i] represents an inclusive interval [left_i, right_i].

Your task is to organize these intervals into groups such that:
• Each interval belongs to exactly one group
• No two intervals in the same group intersect (overlap)

Two intervals intersect if they share at least one common point. For example, [1, 5] and [5, 8] intersect at point 5.

Goal: Return the minimum number of groups needed to organize all intervals.

Example: If you have intervals [[5,10],[6,8],[1,5],[2,3],[1,10]], you need 3 groups because at most 3 intervals overlap at any given time.

Input & Output

example_1.py — Basic Overlap

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

› Output: 3

💡 Note: At time 6, intervals [5,10], [6,8], and [1,10] all overlap, requiring 3 groups. This is the maximum overlap, so we need exactly 3 groups total.

example_2.py — No Overlaps

$ Input: intervals = [[1,3],[5,6],[8,10],[11,13]]

› Output: 1

💡 Note: All intervals are non-overlapping, so they can all be placed in a single group.

example_3.py — Edge Case: Single Point

$ Input: intervals = [[1,1],[2,2],[3,3]]

› Output: 1

💡 Note: Each interval is a single point and they don't overlap, so only 1 group is needed.

Visualization

Tap to expand

Understanding the Visualization

Convert to Events

Each meeting becomes two events: 'meeting starts' and 'meeting ends'

Sort by Time

Process all events in chronological order

Track Active Meetings

At any time, count how many meetings are running simultaneously

Find Peak Usage

The maximum simultaneous meetings = minimum rooms needed

Key Takeaway

🎯 Key Insight: By tracking when intervals start and end, we can efficiently find the peak overlap without checking every pair of intervals.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check every pair of intervals, resulting in n×n comparisons

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track maximum overlap count

✓ Linear Space

Constraints

1 ≤ intervals.length ≤ 10⁵
intervals[i].length == 2
1 ≤ left_i ≤ right_i ≤ 10⁶
Note: Intervals are inclusive on both ends

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal approach uses a sweep line algorithm to convert intervals into events and track the maximum number of simultaneously active intervals. This gives us the minimum groups needed in O(n log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Pairs)	O(n²)	O(1)	For each interval, count how many other intervals it overlaps with
Event Sweep Line Algorithm	O(n log n)	O(n)	Convert intervals to events and sweep through time to find peak overlap

Brute Force (Check All Pairs) — Algorithm Steps

For each interval, count how many intervals overlap with it (including itself)
Keep track of the maximum overlap count found
Return this maximum as the minimum number of groups needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Base Interval

Pick an interval to check against all others

Count Overlaps

For each other interval, check if it overlaps with our base

Track Maximum

Keep the highest overlap count found

Code -

solution.c — C

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

int max(int a, int b) {
    return (a > b) ? a : b;
}

int minGroups(int** intervals, int intervalsSize, int* intervalsColSize) {
    int maxGroups = 1;
    
    // For each interval, count overlaps
    for (int i = 0; i < intervalsSize; i++) {
        int currentOverlaps = 1; // Count itself
        for (int j = 0; j < intervalsSize; j++) {
            if (i != j) {
                // Check if intervals overlap
                if (intervals[i][0] <= intervals[j][1] && intervals[j][0] <= intervals[i][1]) {
                    currentOverlaps++;
                }
            }
        }
        maxGroups = max(maxGroups, currentOverlaps);
    }
    
    return maxGroups;
}

int main() {
    // Parse input and call minGroups
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check every pair of intervals, resulting in n×n comparisons

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track maximum overlap count

✓ Linear Space

Constraints

1 ≤ intervals.length ≤ 10⁵
intervals[i].length == 2
1 ≤ left_i ≤ right_i ≤ 10⁶
Note: Intervals are inclusive on both ends

42.0K Views

High Frequency

~18 min Avg. Time

1.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler