Set Intersection Size At Least Two - Practice Coding Problems

Set Intersection Size At Least Two - Problem

You're tasked with finding the minimum number of integers that can cover multiple intervals with a special constraint: each interval must contain at least two of your chosen integers.

Given a 2D array intervals where intervals[i] = [start_i, end_i] represents all integers from start_i to end_i inclusively, you need to create a containing set - an array of numbers where each interval has at least two integers from your set.

Example: If intervals = [[1,3], [3,7], [8,9]], then [1,2,4,7,8,9] and [2,3,4,8,9] are both valid containing sets, but [2,3,4,8,9] is smaller with only 5 elements.

Your goal is to return the minimum possible size of such a containing set. This is a classic optimization problem that tests your understanding of greedy algorithms and interval scheduling.

Input & Output

example_1.py — Basic Case

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

› Output: 5

💡 Note: We need at least 2 integers in each interval. One optimal solution is [2,3,7,8,9]: interval [1,3] contains {2,3}, interval [3,7] contains {3,7}, and interval [8,9] contains {8,9}.

example_2.py — Overlapping Intervals

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

› Output: 5

💡 Note: The optimal solution is [1,2,3,4,5]. Each interval needs exactly 2 numbers, and due to minimal overlap, we need most numbers individually.

example_3.py — Highly Overlapping

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

› Output: 3

💡 Note: We can use [3,4,5] or [4,5,6]. All intervals [1,5], [2,4], [3,6] will contain at least 2 of these numbers due to high overlap.

Constraints

1 ≤ intervals.length ≤ 3000
intervals[i].length == 2
0 ≤ start_i < end_i ≤ 1000
Each interval must contain at least 2 integers from the result set

Visualization

Tap to expand

Understanding the Visualization

Sort Sections

Arrange building sections by their end positions to process systematically

Greedy Placement

For each section, place guards as far right as possible to maximize future coverage

Check Coverage

Verify each section has at least 2 guards, add more if needed

Optimal Result

This greedy approach guarantees minimum total guards needed

Key Takeaway

🎯 Key Insight: Greedy placement at rightmost positions maximizes coverage efficiency while ensuring every interval gets its required minimum of 2 points.

Asked in

G Google 45 a Amazon 32 ⊞ Microsoft 28 f Meta 19

The optimal solution uses a greedy algorithm with interval sorting. Sort intervals by end points, then greedily place points at the rightmost positions to maximize coverage of future intervals. This achieves O(n log n) time complexity with minimal space usage.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Possible Sets)	O(2^n * m * k)	O(2^n)	Generate all possible containing sets and find the minimum size
Greedy Algorithm (Optimal)	O(n log n)	O(1)	Sort intervals by end point and greedily place points at rightmost positions

Brute Force (Generate All Possible Sets) — Algorithm Steps

Find the range of all possible integers (min start to max end)
Generate all possible subsets of integers in this range
For each subset, check if every interval contains at least 2 integers
Track the minimum size among valid subsets

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Range

Find all integers from minimum start to maximum end

Create Subsets

Generate all possible combinations using bitmasks

Validate Each

Check if each interval has at least 2 numbers

Find Minimum

Track the smallest valid subset size

Code -

solution.c — C

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

int intersectionSizeTwo(int** intervals, int intervalsSize) {
    if (intervalsSize == 0) return 0;
    
    int minVal = INT_MAX, maxVal = INT_MIN;
    for (int i = 0; i < intervalsSize; i++) {
        if (intervals[i][0] < minVal) minVal = intervals[i][0];
        if (intervals[i][1] > maxVal) maxVal = intervals[i][1];
    }
    
    int range = maxVal - minVal + 1;
    int minSize = INT_MAX;
    
    for (int mask = 1; mask < (1 << range); mask++) {
        int subset[1000];
        int subsetSize = 0;
        
        for (int i = 0; i < range; i++) {
            if (mask & (1 << i)) {
                subset[subsetSize++] = minVal + i;
            }
        }
        
        int valid = 1;
        for (int i = 0; i < intervalsSize && valid; 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) {
                valid = 0;
            }
        }
        
        if (valid && subsetSize < minSize) {
            minSize = subsetSize;
        }
    }
    
    return minSize == INT_MAX ? 0 : minSize;
}

int main() {
    printf("Brute force approach - use optimal solution instead\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * m * k)

2^n subsets to check, m intervals to validate, k average interval size

⚠ Quadratic Growth

Space Complexity

O(2^n)

Space to store all possible subsets

⚠ Quadratic Space

27.2K Views

Medium Frequency

~35 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 (Generate All Possible Sets) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler