Non-overlapping Intervals - Practice Coding Problems

Non-overlapping Intervals - Problem

Imagine you're a conference organizer trying to schedule meetings in rooms, but some meetings have overlapping time slots. Your goal is to find the minimum number of meetings to cancel so that no two remaining meetings overlap in time.

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.

Important: Intervals that only touch at a single point are considered non-overlapping. For example, [1, 2] and [2, 3] are perfectly fine together!

Example: If you have meetings [[1,2], [2,3], [3,4], [1,3]], you only need to remove 1 meeting (either [1,2] or [1,3]) to make all remaining meetings non-overlapping.

Input & Output

example_1.py — Standard Case

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

› Output: 1

💡 Note: We can remove [1,3] to make the remaining intervals non-overlapping: [[1,2],[2,3],[3,4]]. Note that [1,2] and [2,3] don't overlap since they only touch at point 2.

example_2.py — Multiple Overlaps

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

› Output: 2

💡 Note: All intervals are identical and overlapping. We need to remove 2 intervals to keep just one: [[1,2]].

example_3.py — No Overlaps

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

› Output: 0

💡 Note: The intervals [1,2] and [2,3] only touch at point 2, so they're non-overlapping. No removals needed.

Visualization

Tap to expand

Understanding the Visualization

Sort by End Time

Arrange meetings by when they finish - earliest finishers first

Keep the First

Always keep the meeting that ends earliest

Check for Conflicts

For each subsequent meeting, see if it starts before the last kept meeting ends

Make Greedy Choice

Cancel conflicting meetings, keep non-conflicting ones

Key Takeaway

🎯 Key Insight: The greedy approach works because keeping intervals that end earliest always leaves maximum space for future non-overlapping intervals, guaranteeing the minimum number of removals.

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n)

2^n subsets to generate, each taking O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and storing current subset

⚡ Linearithmic Space

Constraints

1 ≤ intervals.length ≤ 10⁵
intervals[i].length == 2
-5 × 10⁴ ≤ start_i < end_i ≤ 5 × 10⁴
Important: Intervals touching at endpoints are non-overlapping

Asked in

a Amazon 42 G Google 38 ⊞ Microsoft 31 f Meta 29 Apple 15

The optimal solution uses a greedy algorithm: sort intervals by end time, then iterate through them, removing any interval that overlaps with the previously kept one. This works because always keeping the interval that ends earliest leaves maximum room for future intervals. Time complexity: O(n log n) for sorting, Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n * n)	O(n)	Try every possible subset of intervals to find the largest non-overlapping set
Greedy Algorithm (Optimal)	O(n log n)	O(1)	Sort by end time and greedily pick intervals that end earliest

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible subsets of intervals (2^n combinations)
For each subset, check if all intervals are non-overlapping
Keep track of the maximum size non-overlapping subset found
Return total intervals - maximum non-overlapping size

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all 2^n possible combinations of intervals

Check Validity

For each subset, verify no intervals overlap

Track Maximum

Keep the largest valid subset found

Calculate Result

Return total - maximum valid size

Code -

solution.c — C

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

bool overlaps(int* i1, int* i2) {
    return i1[1] > i2[0] && i2[1] > i1[0];
}

bool isValidSubset(int** subset, int size) {
    for (int i = 0; i < size; i++) {
        for (int j = i + 1; j < size; j++) {
            if (overlaps(subset[i], subset[j])) {
                return false;
            }
        }
    }
    return true;
}

int findMaxNonOverlapping(int** intervals, int totalSize, int idx, int** current, int currentSize) {
    if (idx == totalSize) {
        return isValidSubset(current, currentSize) ? currentSize : 0;
    }
    
    // Don't include current interval
    int maxWithout = findMaxNonOverlapping(intervals, totalSize, idx + 1, current, currentSize);
    
    // Include current interval
    current[currentSize] = intervals[idx];
    int maxWith = findMaxNonOverlapping(intervals, totalSize, idx + 1, current, currentSize + 1);
    
    return maxWithout > maxWith ? maxWithout : maxWith;
}

int eraseOverlapIntervals(int** intervals, int intervalsSize, int* intervalsColSize) {
    if (intervalsSize == 0) return 0;
    
    int** current = (int**)malloc(intervalsSize * sizeof(int*));
    int maxNonOverlapping = findMaxNonOverlapping(intervals, intervalsSize, 0, current, 0);
    free(current);
    
    return intervalsSize - maxNonOverlapping;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n)

2^n subsets to generate, each taking O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and storing current subset

⚡ Linearithmic Space

Constraints

1 ≤ intervals.length ≤ 10⁵
intervals[i].length == 2
-5 × 10⁴ ≤ start_i < end_i ≤ 5 × 10⁴
Important: Intervals touching at endpoints are non-overlapping

67.2K Views

High Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler