Minimize Connected Groups by Inserting Interval

Minimize Connected Groups by Inserting Interval - Problem

Minimize Connected Groups by Inserting Interval

You are given a collection of intervals and need to strategically add one new interval to minimize the number of connected groups.

What you're given:
• A 2D array intervals where intervals[i] = [start_i, end_i]
• An integer k representing the maximum length of the new interval

What you need to do:
Add exactly one new interval [start_new, end_new] such that:
1. The length end_new - start_new ≤ k
2. The number of connected groups is minimized

Connected Groups:
A connected group is a maximal collection of intervals that cover a continuous range with no gaps. For example:
• [[1,2], [2,5], [3,3]] forms one connected group covering [1,5]
• [[1,2], [4,5]] forms two connected groups due to the gap (2,4)

Goal: Return the minimum number of connected groups after adding your strategic interval.

Input & Output

example_1.py — Basic Gap Bridging

$ Input: intervals = [[1,3],[6,9]], k = 2

› Output: 1

💡 Note: We can add interval [3,5] (length 2 ≤ k) to bridge the gap between [1,3] and [6,9], creating one connected group [1,9].

example_2.py — Multiple Gaps

$ Input: intervals = [[1,2],[4,5],[8,9]], k = 1

› Output: 2

💡 Note: We can bridge either gap [2,4] or gap [5,8] with an interval of length 1. Bridging one gap reduces 3 groups to 2 groups. We cannot bridge both gaps with one interval.

example_3.py — No Bridging Possible

$ Input: intervals = [[1,2],[5,6]], k = 1

› Output: 2

💡 Note: The gap between [1,2] and [5,6] is size 3, but k=1. We cannot bridge this gap, so we still have 2 separate groups. We must add an interval anyway, so it forms its own group or extends an existing one.

Constraints

1 ≤ intervals.length ≤ 10⁴
intervals[i].length == 2
1 ≤ start_i ≤ end_i ≤ 10⁵
1 ≤ k ≤ 10⁴
All interval endpoints are integers

Visualization

Tap to expand

Understanding the Visualization

Survey the landscape

Identify existing connected neighborhoods (merged intervals)

Measure gaps

Calculate distances between separate neighborhoods

Check budget

Filter gaps that can be bridged within budget k

Build optimal bridge

Select the gap that connects the most areas

Key Takeaway

🎯 Key Insight: Focus on gaps between existing groups and choose the most impactful bridge within budget constraints.

Asked in

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

The optimal approach uses gap analysis with sorting to identify bridgeable gaps between interval groups. After merging overlapping intervals, we find gaps that can be bridged within the length constraint k and select the gap that maximizes connectivity, achieving O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Gap Analysis with Binary Search	O(n log n)	O(n)	Sort intervals, find gaps, and use binary search to find optimal bridging strategy
Brute Force (Try All Positions)	O(n³)	O(n)	Try every possible new interval position and length, count groups each time

Gap Analysis with Binary Search — Algorithm Steps

Sort and merge overlapping intervals to get distinct groups
Calculate gaps between consecutive groups
For each gap, determine if it can be bridged with length ≤ k
Use binary search to find the gap that provides maximum connectivity benefit
Calculate final number of groups after optimal bridging

Visualization

Tap to expand

Step-by-Step Walkthrough

Merge overlapping intervals

Sort and merge to identify distinct groups

Identify gaps

Find gaps between groups and their sizes

Filter bridgeable gaps

Keep only gaps that can be bridged with length ≤ k

Select optimal gap

Choose the gap that provides maximum benefit

Code -

solution.c — C

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

typedef struct {
    int start, end;
} Interval;

typedef struct {
    int size, index;
} Gap;

int compare_intervals(const void *a, const void *b) {
    return ((Interval*)a)->start - ((Interval*)b)->start;
}

int compare_gaps(const void *a, const void *b) {
    return ((Gap*)a)->size - ((Gap*)b)->size;
}

int minimizeGroups(Interval* intervals, int n, int k) {
    if (n == 0) return 1;
    
    qsort(intervals, n, sizeof(Interval), compare_intervals);
    
    Interval merged[n];
    int mergedCount = 0;
    
    for (int i = 0; i < n; i++) {
        if (mergedCount > 0 && intervals[i].start <= merged[mergedCount-1].end) {
            if (intervals[i].end > merged[mergedCount-1].end) {
                merged[mergedCount-1].end = intervals[i].end;
            }
        } else {
            merged[mergedCount++] = intervals[i];
        }
    }
    
    if (mergedCount == 1) return 1;
    
    Gap gaps[mergedCount-1];
    int gapCount = 0;
    
    for (int i = 0; i < mergedCount - 1; i++) {
        int gapSize = merged[i+1].start - merged[i].end;
        if (gapSize <= k) {
            gaps[gapCount].size = gapSize;
            gaps[gapCount].index = i;
            gapCount++;
        }
    }
    
    if (gapCount == 0) {
        return mergedCount;
    }
    
    qsort(gaps, gapCount, sizeof(Gap), compare_gaps);
    return mergedCount - 1;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n log n) for binary search on gaps

⚡ Linearithmic

Space Complexity

O(n)

Space for storing merged intervals and gap information

⚡ Linearithmic Space

38.2K Views

Medium Frequency

~25 min Avg. Time

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

Gap Analysis with Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler