Non-overlapping Intervals

Non-overlapping Intervals - Problem

Given an array of intervals intervals where intervals[i] = [start_i, end_i], return the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping.

Note that intervals which only touch at a point are non-overlapping. For example, [1, 2] and [2, 3] are non-overlapping.

Input & Output

Example 1 — Basic Overlap

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

› Output: 1

💡 Note: After sorting by end time: [[1,2],[2,3],[1,3],[3,4]]. Keep [1,2], [2,3], [3,4]. Remove [1,3] which overlaps with [1,2].

Example 2 — Multiple Overlaps

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

› Output: 2

💡 Note: All three intervals are identical and overlap. We can only keep one, so remove 2 intervals.

Example 3 — No Overlaps Needed

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

› Output: 0

💡 Note: Intervals [1,2] and [2,3] only touch at point 2, which is considered non-overlapping. No removal needed.

Constraints

1 ≤ intervals.length ≤ 10⁵
intervals[i].length == 2
-5 × 10⁴ ≤ start_i < end_i ≤ 5 × 10⁴

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 🍎 Apple 6

The key insight is to use a greedy approach: sort intervals by end time and always keep the interval that ends earliest among overlapping ones. This maximizes the number of intervals we can keep. Best approach is Greedy Sort by End Time with Time: O(n log n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(2ⁿ × n) Space: O(n)

Try every possible combination of intervals to keep, check if each combination has overlapping intervals, and return the minimum number to remove. This explores all 2^n possibilities.

Greedy - Sort by End Time

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

Sort all intervals by their end times. Then greedily select intervals: always choose the next interval that starts after the current one ends. This maximizes the number of non-overlapping intervals we can keep.

Sort by Start Time + Count Overlaps

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

Sort intervals by start time, then iterate through and count how many intervals need to be removed when overlaps occur. When intervals overlap, we remove the one with later end time to minimize future conflicts.

Brute Force - Try All Combinations — Algorithm Steps

Generate all possible subsets of intervals
For each subset, check if intervals are non-overlapping
Track the maximum size non-overlapping subset
Return total intervals minus maximum non-overlapping size

Visualization

Tap to expand

Step-by-Step Walkthrough

Input

Array of intervals to process

Generate Subsets

Create all 2^n possible combinations

Validate

Check each subset for overlaps

Find Maximum

Keep track of largest valid subset

Code -

solution.c — C

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

bool isNonOverlapping(int intervals[][2], int indices[], int count) {
    if (count <= 1) return true;
    
    // Create temporary array for sorting
    int temp[count][2];
    for (int i = 0; i < count; i++) {
        temp[i][0] = intervals[indices[i]][0];
        temp[i][1] = intervals[indices[i]][1];
    }
    
    // Simple bubble sort by start time
    for (int i = 0; i < count - 1; i++) {
        for (int j = 0; j < count - i - 1; j++) {
            if (temp[j][0] > temp[j + 1][0]) {
                int t0 = temp[j][0], t1 = temp[j][1];
                temp[j][0] = temp[j + 1][0];
                temp[j][1] = temp[j + 1][1];
                temp[j + 1][0] = t0;
                temp[j + 1][1] = t1;
            }
        }
    }
    
    // Check for overlaps
    for (int i = 1; i < count; i++) {
        if (temp[i][0] < temp[i-1][1]) {
            return false;
        }
    }
    
    return true;
}

int solution(int intervals[][2], int n) {
    int maxNonOverlapping = 0;
    
    // Try all possible subsets using bit manipulation
    for (int mask = 0; mask < (1 << n); mask++) {
        int indices[n];
        int count = 0;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                indices[count++] = i;
            }
        }
        
        // Check if this subset is non-overlapping
        if (isNonOverlapping(intervals, indices, count)) {
            if (count > maxNonOverlapping) {
                maxNonOverlapping = count;
            }
        }
    }
    
    return n - maxNonOverlapping;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for [[a,b],[c,d]] format
    int intervals[20][2];
    int n = 0;
    char* ptr = line + 1; // Skip first [
    
    while (*ptr && *ptr != ']' || *(ptr+1) == ',') {
        if (*ptr == '[') {
            ptr++;
            intervals[n][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            ptr++;
            intervals[n][1] = atoi(ptr);
            while (*ptr && *ptr != ']') ptr++;
            ptr++;
            n++;
        } else {
            ptr++;
        }
    }
    
    int result = solution(intervals, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n)

Generate 2^n subsets, each takes O(n) time to validate for overlaps

✓ Linear Growth

Space Complexity

O(n)

Recursion depth and temporary storage for current subset

⚡ Linearithmic Space

89.4K Views

High Frequency

~25 min Avg. Time

2.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

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler