Count Ways to Group Overlapping Ranges - Practice Coding Problems

Count Ways to Group Overlapping Ranges - Problem

Array Sorting Medium

Imagine you're a data analyst tasked with organizing overlapping time intervals into two separate groups. You have a collection of ranges where each range [start, end] represents a continuous interval of integers.

Your challenge is to split these ranges into exactly two groups (either group can be empty) following one crucial rule: any two ranges that overlap must be placed in the same group.

Two ranges are considered overlapping if they share at least one common integer. For example:

[1, 3] and [2, 5] overlap because they both contain 2 and 3
[1, 2] and [3, 4] don't overlap as they share no common integers

Your goal is to count the total number of valid ways to perform this grouping. Since the answer can be astronomically large, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: The two ranges overlap ([5,15] contains [6,10]), so they must be in the same group. We can either put both in group A or both in group B, giving us 2 ways total.

example_2.py — Non-overlapping Ranges

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

› Output: 4

💡 Note: After sorting and merging: [1,3] merges with [2,5] and [4,8] to form [1,8]. [10,20] remains separate. Two independent components give us 2² = 4 ways to group them.

example_3.py — Single Range

$ Input: ranges = [[1,1]]

› Output: 2

💡 Note: With only one range, we can put it in either group A or group B, resulting in 2 possible ways.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Sort Events

Arrange all time ranges chronologically

Merge Conflicts

Combine overlapping time slots into single blocks

Count Blocks

Each merged block represents one independent group

Calculate Ways

With n independent blocks, we have 2^n assignment possibilities

Key Takeaway

🎯 Key Insight: Overlapping ranges must be grouped together, forming connected components. Each independent component can be assigned to either group, giving us 2^(components) total ways to split them.

Asked in

G Google 42 f Meta 35 a Amazon 28 ⊞ Microsoft 22

The optimal approach uses interval merging after sorting. Key insight: overlapping ranges form connected components that must be grouped together. Each independent component can be assigned to either group, giving us 2^n possible ways where n is the number of merged intervals. Time complexity: O(n log n) for sorting plus O(n) for merging.

Common Approaches

Approach	Time	Space	Notes
✓ Merge Intervals + Counting (Optimal)	O(n log n)	O(1)	Sort ranges, merge overlapping ones, then count independent components
Brute Force (Generate All Groupings)	O(2^n × n²)	O(1)	Generate all possible 2^n groupings and check validity

Merge Intervals + Counting (Optimal) — Algorithm Steps

Sort ranges by their start points
Merge overlapping ranges using two pointers technique
Count the number of independent merged intervals
Return 2^(count of independent intervals) mod (10^9 + 7)

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Ranges

Sort all ranges by their start points

Merge Overlaps

Merge consecutive overlapping ranges

Count Components

Each merged interval is an independent component

Calculate Result

Result is 2^(number of components)

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    int* rangeA = *(int**)a;
    int* rangeB = *(int**)b;
    return rangeA[0] - rangeB[0];
}

long long modPow(long long base, int exp, int mod) {
    long long result = 1;
    base %= mod;
    while (exp > 0) {
        if (exp & 1) result = (result * base) % mod;
        base = (base * base) % mod;
        exp >>= 1;
    }
    return result;
}

int countWays(int** ranges, int rangesSize, int* rangesColSize) {
    if (rangesSize == 0) return 1;
    
    int MOD = 1000000007;
    
    // Sort ranges by start point
    qsort(ranges, rangesSize, sizeof(int*), compare);
    
    // Merge overlapping ranges and count independent components
    int components = 1;
    int currentEnd = ranges[0][1];
    
    for (int i = 1; i < rangesSize; i++) {
        int start = ranges[i][0];
        int end = ranges[i][1];
        
        if (start <= currentEnd) {
            // Overlapping - extend current component
            if (end > currentEnd) currentEnd = end;
        } else {
            // Non-overlapping - new independent component
            components++;
            currentEnd = end;
        }
    }
    
    // Each independent component can go to either group
    return (int)modPow(2, components, MOD);
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n) for merging intervals

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for merging in-place

✓ Linear Space

43.7K Views

Medium Frequency

~18 min Avg. Time

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

Merge Intervals + Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler