Maximum Score of Non-overlapping Intervals

Maximum Score of Non-overlapping Intervals - Problem

You are given a 2D integer array intervals, where intervals[i] = [li, ri, weighti]. Interval i starts at position li and ends at ri, and has a weight of weighti.

You can choose up to 4 non-overlapping intervals. The score of the chosen intervals is defined as the total sum of their weights.

Return the lexicographically smallest array of at most 4 indices from intervals with maximum score, representing your choice of non-overlapping intervals.

Note: Two intervals are said to be non-overlapping if they do not share any points. In particular, intervals sharing a left or right boundary are considered overlapping.

Input & Output

Example 1 — Basic Case

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

› Output: [1]

💡 Note: We can only choose one interval due to overlaps. Interval at index 1 has weight 3, which is the maximum. So we return [1].

Example 2 — Non-overlapping Intervals

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

› Output: [0,1,2]

💡 Note: All intervals are non-overlapping. We can take all three: indices [0,1,2] with total weight 1+2+3=6.

Example 3 — Choose Best Combination

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

› Output: [0,2,3]

💡 Note: Best non-overlapping combination: intervals 0 [1,3], 2 [4,6], and 3 [7,8] with total weight 2+1+4=7.

Constraints

1 ≤ intervals.length ≤ 10⁴
intervals[i].length == 3
1 ≤ l_i ≤ r_i ≤ 10⁹
1 ≤ weight_i ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 10

The key insight is to sort intervals by end time and use dynamic programming with binary search to efficiently find the optimal combination. The brute force approach tries all combinations in O(n⁴) time, while the optimized approach uses sorting and DP in O(n log n) time. Best approach: Sort + DP. Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force - Try All Combinations

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

For each possible subset of 1, 2, 3, or 4 intervals, check if they are non-overlapping and track the maximum weight sum. Among all maximum weight combinations, return the lexicographically smallest indices.

Sort and Dynamic Programming

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

Sort intervals by their end times to enable efficient overlap checking. Use dynamic programming to track the best combination of up to 4 intervals, with binary search to quickly find the last non-overlapping interval.

Brute Force - Try All Combinations — Algorithm Steps

Generate all combinations of 1, 2, 3, and 4 intervals
For each combination, check if intervals are non-overlapping
Track maximum weight and lexicographically smallest indices

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible combinations of 1, 2, 3, 4 intervals

Check Overlaps

For each combination, verify no intervals overlap

Track Maximum

Keep the lexicographically smallest indices with maximum weight

Code -

solution.c — C

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

int isOverlapping(int** intervals, int i, int j) {
    return !(intervals[i][1] < intervals[j][0] || intervals[j][1] < intervals[i][0]);
}

int isValidCombination(int** intervals, int* indices, int size) {
    for (int i = 0; i < size; i++) {
        for (int j = i + 1; j < size; j++) {
            if (isOverlapping(intervals, indices[i], indices[j])) {
                return 0;
            }
        }
    }
    return 1;
}

int lexSmaller(int* a, int sizeA, int* b, int sizeB) {
    if (sizeB == 0) return 1;
    for (int i = 0; i < sizeA && i < sizeB; i++) {
        if (a[i] < b[i]) return 1;
        if (a[i] > b[i]) return 0;
    }
    return sizeA < sizeB;
}

void generateCombinations(int** intervals, int intervalsSize, int* current, int currentSize, 
                         int start, int k, int* maxWeight, int* bestIndices, int* bestSize) {
    if (currentSize == k) {
        if (isValidCombination(intervals, current, currentSize)) {
            int weight = 0;
            for (int i = 0; i < currentSize; i++) {
                weight += intervals[current[i]][2];
            }
            
            if (weight > *maxWeight || (weight == *maxWeight && lexSmaller(current, currentSize, bestIndices, *bestSize))) {
                *maxWeight = weight;
                *bestSize = currentSize;
                for (int i = 0; i < currentSize; i++) {
                    bestIndices[i] = current[i];
                }
            }
        }
        return;
    }
    
    for (int i = start; i < intervalsSize; i++) {
        current[currentSize] = i;
        generateCombinations(intervals, intervalsSize, current, currentSize + 1, i + 1, k, maxWeight, bestIndices, bestSize);
    }
}

int* solution(int** intervals, int intervalsSize, int* returnSize) {
    int maxWeight = 0;
    int* bestIndices = (int*)malloc(4 * sizeof(int));
    *returnSize = 0;
    
    int* current = (int*)malloc(4 * sizeof(int));
    
    // Try all combinations of 1, 2, 3, 4 intervals
    for (int k = 1; k <= (intervalsSize < 4 ? intervalsSize : 4); k++) {
        generateCombinations(intervals, intervalsSize, current, 0, 0, k, &maxWeight, bestIndices, returnSize);
    }
    
    free(current);
    return bestIndices;
}

int** parseInput(char* line, int* size) {
    *size = 0;
    if (strcmp(line, "[]") == 0) return NULL;
    
    // Simple parsing - count intervals first
    int count = 0;
    for (int i = 0; line[i]; i++) {
        if (line[i] == '[' && i > 0) count++;
    }
    
    int** intervals = (int**)malloc(count * sizeof(int*));
    for (int i = 0; i < count; i++) {
        intervals[i] = (int*)malloc(3 * sizeof(int));
    }
    
    // Parse intervals
    char* token = strtok(line, "[],");
    int intervalIdx = 0, numIdx = 0;
    
    while (token != NULL && intervalIdx < count) {
        if (strlen(token) > 0) {
            intervals[intervalIdx][numIdx] = atoi(token);
            numIdx++;
            if (numIdx == 3) {
                intervalIdx++;
                numIdx = 0;
            }
        }
        token = strtok(NULL, "[],");
    }
    
    *size = intervalIdx;
    return intervals;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int intervalsSize;
    int** intervals = parseInput(line, &intervalsSize);
    
    if (intervals == NULL) {
        printf("[]\n");
        return 0;
    }
    
    int returnSize;
    int* result = solution(intervals, intervalsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    for (int i = 0; i < intervalsSize; i++) {
        free(intervals[i]);
    }
    free(intervals);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

We check all combinations of up to 4 intervals from n intervals

⚡ Linearithmic

Space Complexity

O(1)

Only using variables to track current combination and best result

⚡ Linearithmic Space

23.4K 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 - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler