Maximum Sum of Two Non-Overlapping Subarrays

Maximum Sum of Two Non-Overlapping Subarrays - Problem

Given an integer array nums and two integers firstLen and secondLen, find two non-overlapping subarrays that maximize their combined sum.

The first subarray must have exactly firstLen elements, and the second subarray must have exactly secondLen elements. These subarrays can appear in any order in the original array - the shorter one could come before or after the longer one.

Goal: Return the maximum possible sum of elements from both subarrays combined.

Example: For array [0,6,5,2,2,5,1,9,4] with firstLen=1 and secondLen=2, we could choose subarray [9] (length 1) and [6,5] (length 2) for a total sum of 9 + 11 = 20.

Input & Output

example_1.py — Basic Case

$ Input: nums = [0,6,5,2,2,5,1,9,4], firstLen = 1, secondLen = 2

› Output: 20

💡 Note: One choice of subarrays is [9] with length 1, and [6,5] with length 2. The sum is 9 + 6 + 5 = 20. We can also choose [6] and [2,5] for sum 6 + 2 + 5 = 13, but 20 is better.

example_2.py — Different Lengths

$ Input: nums = [3,8,1,3,2,1,8,9,0], firstLen = 3, secondLen = 2

› Output: 29

💡 Note: One choice is [3,8,1] with length 3, and [8,9] with length 2. Sum = (3+8+1) + (8+9) = 12 + 17 = 29. Another choice is [1,8,9] and [3,8] for sum 18 + 11 = 29.

example_3.py — Edge Case Small Array

$ Input: nums = [2,1,5,6,0,9,5,0,3,8], firstLen = 4, secondLen = 3

› Output: 31

💡 Note: Choose [5,6,0,9] with length 4 (sum=20) and [0,3,8] with length 3 (sum=11). Total sum = 20 + 11 = 31.

Visualization

Tap to expand

Understanding the Visualization

Setup

We have a row of rooms (array elements) and two groups needing contiguous rooms

Constraint

Groups cannot overlap - they need separate, non-overlapping room blocks

Goal

Maximize total revenue (sum of both subarrays) by optimal placement

Strategy

Use sliding windows to efficiently find the best placement for both groups

Key Takeaway

🎯 Key Insight: By maintaining the maximum subarray sum seen so far in one direction while sliding the window in the other direction, we can find the optimal combination in O(n) time instead of checking all O(n²) possibilities.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) to compute all subarray sums, O(n²) to check all combinations

⚠ Quadratic Growth

Space Complexity

O(n)

Storing all precomputed subarray sums

⚡ Linearithmic Space

Constraints

1 ≤ firstLen, secondLen ≤ 1000
2 ≤ nums.length ≤ 1000
firstLen + secondLen ≤ nums.length
0 ≤ nums[i] ≤ 1000
The two subarrays must be non-overlapping

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 22 Apple 18

The optimal solution uses dynamic programming with sliding windows to solve this in O(n) time and O(1) space. The key insight is to track the maximum subarray sum seen so far in one direction while sliding the window for the other subarray. By handling both possible orderings (firstLen before secondLen and vice versa), we can find the optimal non-overlapping combination in a single pass through the array.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Brute Force (Sliding Window)	O(n²)	O(n)	Use sliding window to avoid recalculating subarray sums from scratch
Brute Force (Try All Positions)	O(n³)	O(1)	Try every possible position for both subarrays and check all valid combinations
Dynamic Programming with Sliding Window (Optimal)	O(n)	O(1)	Single pass solution using sliding windows and tracking maximum sums in both directions

Optimized Brute Force (Sliding Window) — Algorithm Steps

Use sliding window to precompute all firstLen subarray sums
Use sliding window to precompute all secondLen subarray sums
For each firstLen subarray, find best non-overlapping secondLen subarray
Consider both orders: firstLen before secondLen and vice versa

Visualization

Tap to expand

Step-by-Step Walkthrough

Precompute All Sums

Use sliding window to calculate all possible subarray sums efficiently

Check Non-overlapping Pairs

For each sum pair, verify they don't overlap in the original array

Track Maximum

Keep track of the best combination found so far

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int maxSumTwoNoOverlap(int* nums, int numsSize, int firstLen, int secondLen) {
    // Precompute all subarray sums using sliding window
    int* firstSums = malloc((numsSize - firstLen + 1) * sizeof(int));
    int* secondSums = malloc((numsSize - secondLen + 1) * sizeof(int));
    
    // Calculate firstLen sums
    int windowSum = 0;
    for (int i = 0; i < firstLen; i++) {
        windowSum += nums[i];
    }
    firstSums[0] = windowSum;
    
    for (int i = firstLen; i < numsSize; i++) {
        windowSum = windowSum - nums[i - firstLen] + nums[i];
        firstSums[i - firstLen + 1] = windowSum;
    }
    
    // Calculate secondLen sums
    windowSum = 0;
    for (int i = 0; i < secondLen; i++) {
        windowSum += nums[i];
    }
    secondSums[0] = windowSum;
    
    for (int i = secondLen; i < numsSize; i++) {
        windowSum = windowSum - nums[i - secondLen] + nums[i];
        secondSums[i - secondLen + 1] = windowSum;
    }
    
    int maxSum = 0;
    int firstCount = numsSize - firstLen + 1;
    int secondCount = numsSize - secondLen + 1;
    
    // Try all non-overlapping combinations
    for (int i = 0; i < firstCount; i++) {
        // secondLen before firstLen
        for (int j = 0; j <= max(-1, i - secondLen); j++) {
            maxSum = max(maxSum, firstSums[i] + secondSums[j]);
        }
        
        // secondLen after firstLen
        for (int j = i + firstLen; j < secondCount; j++) {
            maxSum = max(maxSum, firstSums[i] + secondSums[j]);
        }
    }
    
    free(firstSums);
    free(secondSums);
    return maxSum;
}

int main() {
    int nums[] = {0, 6, 5, 2, 2, 5, 1, 9, 4};
    printf("%d\n", maxSumTwoNoOverlap(nums, 9, 1, 2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) to compute all subarray sums, O(n²) to check all combinations

⚠ Quadratic Growth

Space Complexity

O(n)

Storing all precomputed subarray sums

⚡ Linearithmic Space

Constraints

1 ≤ firstLen, secondLen ≤ 1000
2 ≤ nums.length ≤ 1000
firstLen + secondLen ≤ nums.length
0 ≤ nums[i] ≤ 1000
The two subarrays must be non-overlapping

47.0K Views

Medium-High Frequency

~18 min Avg. Time

2.2K 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

Optimized Brute Force (Sliding Window) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler