Set Intersection Size At Least Two

Set Intersection Size At Least Two - Problem

You are given a 2D integer array intervals where intervals[i] = [start_i, end_i] represents all the integers from start_i to end_i inclusively.

A containing set is an array nums where each interval from intervals has at least two integers in nums.

For example, if intervals = [[1,3], [3,7], [8,9]], then [1,2,4,7,8,9] and [2,3,4,8,9] are containing sets.

Return the minimum possible size of a containing set.

Input & Output

Example 1 — Basic Case

$ Input: intervals = [[1,3], [3,7], [8,9]]

› Output: 5

💡 Note: We need a set where each interval has at least 2 numbers. One optimal set is [2,3,7,8,9]: interval [1,3] contains {2,3}, interval [3,7] contains {3,7}, interval [8,9] contains {8,9}.

Example 2 — Overlapping Intervals

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

› Output: 3

💡 Note: One optimal set is [2,3,4]: all intervals contain at least 2 of these numbers.

Example 3 — Single Interval

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

› Output: 2

💡 Note: The interval [1,2] needs at least 2 numbers, so minimum set is [1,2].

Constraints

1 ≤ intervals.length ≤ 3000
intervals[i].length == 2
0 ≤ start_i < end_i ≤ 3000

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 M Microsoft 15

The key insight is to use a greedy approach: sort intervals by end points and select the rightmost possible numbers to maximize coverage for future intervals. Best approach is greedy sorting with Time: O(n log n), Space: O(1).

Common Approaches

✓ Brute Force - Generate All Sets

⏱️ Time: O(2^n × m) Space: O(n)

Try all possible combinations of numbers that could be in the containing set. For each combination, check if every interval has at least 2 numbers from the set.

Greedy - Sort by End Points

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

Sort intervals by their end points. For each interval, greedily choose the rightmost two numbers that satisfy the constraint. This ensures maximum coverage for future intervals.

Brute Force - Generate All Sets — Algorithm Steps

Find the range of all possible numbers
Generate all possible subsets
Check each subset to see if it's a valid containing set
Return the minimum size among valid sets

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Range

Determine all possible numbers

Generate Sets

Try all possible subsets

Validate

Check if each interval has ≥2 numbers

Code -

solution.c — C

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

bool isValidSet(int* subset, int subsetSize, int intervals[][2], int intervalCount) {
    for (int i = 0; i < intervalCount; i++) {
        int count = 0;
        for (int j = 0; j < subsetSize; j++) {
            if (subset[j] >= intervals[i][0] && subset[j] <= intervals[i][1]) {
                count++;
            }
        }
        if (count < 2) return false;
    }
    return true;
}

bool hasValidSubset(int* nums, int numsSize, int intervals[][2], int intervalCount,
                   int size, int start, int* current, int currentSize) {
    if (currentSize == size) {
        return isValidSet(current, currentSize, intervals, intervalCount);
    }
    
    for (int i = start; i < numsSize; i++) {
        current[currentSize] = nums[i];
        if (hasValidSubset(nums, numsSize, intervals, intervalCount, size, i + 1, current, currentSize + 1)) {
            return true;
        }
    }
    return false;
}

int solution(int intervals[][2], int intervalCount) {
    if (intervalCount == 0) return 0;
    
    int minVal = intervals[0][0], maxVal = intervals[0][1];
    for (int i = 0; i < intervalCount; i++) {
        if (intervals[i][0] < minVal) minVal = intervals[i][0];
        if (intervals[i][1] > maxVal) maxVal = intervals[i][1];
    }
    
    int* allNums = (int*)malloc((maxVal - minVal + 1) * sizeof(int));
    for (int i = 0; i <= maxVal - minVal; i++) {
        allNums[i] = minVal + i;
    }
    int numsSize = maxVal - minVal + 1;
    
    int minSize = 2 * intervalCount;
    int* current = (int*)malloc(minSize * sizeof(int));
    
    for (int size = 0; size < minSize; size++) {
        if (hasValidSubset(allNums, numsSize, intervals, intervalCount, size, 0, current, 0)) {
            free(allNums);
            free(current);
            return size;
        }
    }
    
    free(allNums);
    free(current);
    return minSize;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for small cases
    int intervals[100][2];
    int count = 0;
    
    char* ptr = line;
    while (*ptr) {
        if (*ptr == '[' && *(ptr+1) != '[') {
            sscanf(ptr, "[%d,%d]", &intervals[count][0], &intervals[count][1]);
            count++;
        }
        ptr++;
    }
    
    printf("%d\n", solution(intervals, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × m)

Generate 2^n subsets where n is range of numbers, check each against m intervals

⚠ Quadratic Growth

Space Complexity

O(n)

Store current subset being evaluated

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 min Avg. Time

890 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 - Generate All Sets — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler