Minimize Connected Groups by Inserting Interval

Minimize Connected Groups by Inserting Interval - Problem

You are given a 2D array intervals, where intervals[i] = [start_i, end_i] represents the start and the end of interval i. You are also given an integer k.

You must add exactly one new interval [start_new, end_new] to the array such that:

The length of the new interval, end_new - start_new, is at most k.
After adding, the number of connected groups in intervals is minimized.

A connected group of intervals is a maximal collection of intervals that, when considered together, cover a continuous range from the smallest point to the largest point with no gaps between them.

Examples:

A group of intervals [[1, 2], [2, 5], [3, 3]] is connected because together they cover the range from 1 to 5 without any gaps.
However, a group of intervals [[1, 2], [3, 4]] is not connected because the segment (2, 3) is not covered.

Return the minimum number of connected groups after adding exactly one new interval to the array.

Input & Output

Example 1 — Bridge Two Groups

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

› Output: 1

💡 Note: Original has 2 groups: [1,3] and [5,7]. Gap between them is (3,5) with size 2. We can add [3,5] (length=2≤k) to connect both groups into one.

Example 2 — Cannot Bridge Fully

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

› Output: 2

💡 Note: Gap is (2,6) with size 4 > k=2. Best we can do is add [2,4] or [4,6], but this creates 3 total groups. Better to add [1,1] (extends first group) keeping 2 groups.

Example 3 — Already Connected

$ Input: intervals = [[1,5],[3,7]], k = 1

› Output: 1

💡 Note: Intervals overlap, so already 1 connected group. Adding any new interval keeps it at 1 group minimum.

Constraints

0 ≤ intervals.length ≤ 10⁴
intervals[i].length == 2
-10⁹ ≤ start_i ≤ end_i ≤ 10⁹
0 ≤ k ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 35 M Microsoft 28 a Amazon 22

The key insight is to sort intervals, merge overlapping ones to identify connected groups, then find gaps between groups that can be bridged with a new interval of length ≤ k. Best approach is sort-first with time O(n log n) and space O(n).

Common Approaches

✓ Brute Force - Try All Possible Intervals

⏱️ Time: O(R² × n log n) Space: O(n)

Generate all possible intervals with length ≤ k within a reasonable range, add each one to the original intervals, merge overlapping intervals, and count connected groups. Choose the configuration with minimum groups.

Optimized - Sort and Find Best Gap

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

First sort intervals and merge overlapping ones to identify connected groups. Then find gaps between groups and determine which gap can be optimally filled with a new interval of length ≤ k to minimize total groups.

Brute Force - Try All Possible Intervals — Algorithm Steps

Step 1: Find the range of all existing intervals
Step 2: Generate all possible new intervals [start, end] where end - start ≤ k
Step 3: For each candidate interval, merge with existing intervals and count groups
Step 4: Return minimum group count found

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Groups

Count existing connected groups

Try New Intervals

Test all possible intervals of length ≤ k

Find Minimum

Return configuration with fewest groups

Code -

solution.c — C

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

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

int countGroups(int** intervals, int n) {
    if (n == 0) return 0;
    
    qsort(intervals, n, sizeof(int*), compare);
    int groups = 1;
    int currentEnd = intervals[0][1];
    
    for (int i = 1; i < n; i++) {
        if (intervals[i][0] > currentEnd) {
            groups++;
            currentEnd = intervals[i][1];
        } else {
            if (intervals[i][1] > currentEnd) {
                currentEnd = intervals[i][1];
            }
        }
    }
    
    return groups;
}

int solution(int** intervals, int n, int k) {
    if (n == 0) return 1;
    
    // Find coordinate range
    int minCoord = INT_MAX, maxCoord = INT_MIN;
    for (int i = 0; i < n; i++) {
        if (intervals[i][0] < minCoord) minCoord = intervals[i][0];
        if (intervals[i][1] > maxCoord) maxCoord = intervals[i][1];
    }
    
    // Try all possible new intervals
    int minGroups = countGroups(intervals, n);
    
    // Limit search range to avoid timeout
    int searchRange = 100;
    if (maxCoord - minCoord + k < searchRange) {
        searchRange = maxCoord - minCoord + k;
    }
    
    // Allocate memory for new intervals array
    int** newIntervals = malloc((n + 1) * sizeof(int*));
    for (int i = 0; i < n; i++) {
        newIntervals[i] = intervals[i];
    }
    int* newInterval = malloc(2 * sizeof(int));
    newIntervals[n] = newInterval;
    
    for (int start = minCoord - k; start <= maxCoord + k; start++) {
        int maxLength = (k < searchRange) ? k : searchRange;
        for (int length = 0; length <= maxLength; length++) {
            int end = start + length;
            newInterval[0] = start;
            newInterval[1] = end;
            int groups = countGroups(newIntervals, n + 1);
            if (groups < minGroups) {
                minGroups = groups;
            }
        }
    }
    
    free(newInterval);
    free(newIntervals);
    
    return minGroups;
}

int main() {
    // Simple parsing - assumes small input for demo
    int** intervals = malloc(100 * sizeof(int*));
    int n = 0;
    int k;
    
    // Read intervals (simplified parsing)
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse [[a,b],[c,d]] format - simplified
    char* ptr = line + 1; // Skip first [
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            intervals[n] = malloc(2 * sizeof(int));
            intervals[n][0] = strtol(ptr, &ptr, 10);
            while (*ptr == ',' || *ptr == ' ') ptr++;
            intervals[n][1] = strtol(ptr, &ptr, 10);
            n++;
        }
        ptr++;
    }
    
    scanf("%d", &k);
    
    int result = solution(intervals, n, k);
    printf("%d\n", result);
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(intervals[i]);
    }
    free(intervals);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(R² × n log n)

R is the coordinate range, we try R² possible intervals, each requiring O(n log n) merge operation

⚡ Linearithmic

Space Complexity

O(n)

Space for storing and sorting intervals during merge operations

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

892 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 Possible Intervals — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler