Count Ways to Group Overlapping Ranges

Count Ways to Group Overlapping Ranges - Problem

Array Sorting Medium

You are given a 2D integer array ranges where ranges[i] = [start_i, end_i] denotes that all integers between start_i and end_i (both inclusive) are contained in the i^th range.

You are to split ranges into two (possibly empty) groups such that:

Each range belongs to exactly one group.
Any two overlapping ranges must belong to the same group.

Two ranges are said to be overlapping if there exists at least one integer that is present in both ranges.

For example, [1, 3] and [2, 5] are overlapping because 2 and 3 occur in both ranges.

Return the total number of ways to split ranges into two groups. Since the answer may be very large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Overlapping Ranges

$ Input: ranges = [[6,10],[5,15]]

› Output: 2

💡 Note: The two ranges [6,10] and [5,15] overlap (they share integers 6,7,8,9,10), so they must be in the same group. We can put both in group 1 or both in group 2, giving us 2 ways total.

Example 2 — Non-overlapping Ranges

$ Input: ranges = [[1,3],[10,20],[2,5],[4,8]]

› Output: 4

💡 Note: After sorting: [1,3],[2,5],[4,8],[10,20]. Ranges [1,3],[2,5],[4,8] all overlap and form one component. Range [10,20] is separate. So we have 2 components, giving us 2² = 4 ways.

Example 3 — All Separate

$ Input: ranges = [[1,2],[3,4],[5,6]]

› Output: 8

💡 Note: All three ranges are non-overlapping, so we have 3 independent components. Each can go to either group: 2³ = 8 ways total.

Constraints

1 ≤ ranges.length ≤ 10⁴
ranges[i].length == 2
0 ≤ start_i ≤ end_i ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is that overlapping ranges must be in the same group, forming connected components. After sorting and merging overlapping ranges, each independent component can choose either group. Best approach is Sort and Merge with Time: O(n log n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Groupings

⏱️ Time: O(n × 2ⁿ) Space: O(n)

For each range, try assigning it to group 1 or group 2, then check if overlapping ranges are in the same group. This explores all 2^n possible groupings.

Sort and Merge Overlapping Ranges

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

Sort the ranges and merge overlapping ones to find connected components. Each component can independently be assigned to either group, giving us 2^(number of components) total ways.

Brute Force - Try All Groupings — Algorithm Steps

Generate all possible group assignments (2^n)
For each assignment, check if overlapping ranges are in same group
Count valid assignments

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all 2^n possible group assignments

Validate

Check if overlapping ranges are in same group

Count

Count valid assignments

Code -

solution.c — C

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

#define MOD 1000000007

int ranges[1000][2];
int n;

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

int overlaps(int* r1, int* r2) {
    return max(r1[0], r2[0]) <= min(r1[1], r2[1]);
}

int isValid(int* assignment) {
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (overlaps(ranges[i], ranges[j])) {
                if (assignment[i] != assignment[j]) {
                    return 0;
                }
            }
        }
    }
    return 1;
}

int generateAssignments(int index, int* current) {
    if (index == n) {
        return isValid(current) ? 1 : 0;
    }
    
    int count = 0;
    current[index] = 0;
    count = (count + generateAssignments(index + 1, current)) % MOD;
    current[index] = 1;
    count = (count + generateAssignments(index + 1, current)) % MOD;
    return count;
}

int solution() {
    int assignment[1000] = {0};
    return generateAssignments(0, assignment);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for [[a,b],[c,d],...]
    char* ptr = line + 1; // Skip first [
    n = 0;
    while (*ptr && *ptr != ']' || *(ptr+1) != '\0') {
        if (*ptr == '[') {
            ptr++;
            ranges[n][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            ptr++;
            ranges[n][1] = atoi(ptr);
            while (*ptr && *ptr != ']') ptr++;
            n++;
        }
        ptr++;
    }
    
    printf("%d\n", solution());
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2ⁿ)

2^n possible groupings, each taking O(n²) time to validate overlaps

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth and temporary group assignment array

⚡ Linearithmic Space

12.0K Views

Medium Frequency

~25 min Avg. Time

245 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 - Try All Groupings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler