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, return the maximum sum of elements in two non-overlapping subarrays with lengths firstLen and secondLen.

The array with length firstLen could occur before or after the array with length secondLen, but they have to be non-overlapping.

A subarray is a contiguous part of an array.

Input & Output

Example 1 — Basic Case

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

› Output: 20

💡 Note: One choice: secondLen subarray [0,6] with sum 6, firstLen subarray [9] with sum 9. Total = 6 + 9 = 15. Better choice: secondLen subarray [5,1] with sum 6, firstLen subarray [9] with sum 9. Actually optimal: secondLen [9,4] = 13, firstLen [6] = 6, but they overlap. Best non-overlapping: firstLen [9] = 9, secondLen [0,6] = 6. Wait - let me recalculate: nums[7:9] = [9,4] sum=13, nums[0:2] = [0,6] sum=6, total=19. But actually nums[1:3]=[6,5] sum=11, nums[7]=[9] sum=9, total=20.

Example 2 — Equal Lengths

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

› Output: 23

💡 Note: Best firstLen=[9,4] at indices 3-4 with sum 13, best non-overlapping secondLen=[5,5] at indices 0-1 with sum 10. Total = 13 + 10 = 23.

Example 3 — Small Array

$ Input: nums = [1,2,1,2,6,7,5,1], firstLen = 2, secondLen = 3

› Output: 21

💡 Note: Best combination: secondLen=[6,7,5] at indices 4-6 with sum 18, firstLen=[1,2] at indices 0-1 with sum 3. Total = 18 + 3 = 21.

Constraints

1 ≤ firstLen, secondLen ≤ 1000
2 ≤ nums.length ≤ 1000
firstLen + secondLen ≤ nums.length
0 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Facebook 12

The key insight is to use sliding window technique with prefix maximum tracking to efficiently find the best non-overlapping subarray pair. Best approach uses sliding window with prefix maximum to avoid redundant calculations. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Try All Pairs

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

Generate all possible subarrays of length firstLen and secondLen, then find the pair with maximum sum that don't overlap. Check both orders: firstLen before secondLen and secondLen before firstLen.

Sliding Window with Prefix Maximum

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

Slide windows of both lengths across the array while tracking the maximum sum subarray seen so far. This avoids recalculating overlapping portions and handles both orderings efficiently.

Brute Force - Try All Pairs — Algorithm Steps

Find all subarrays of length firstLen with their sums
Find all subarrays of length secondLen with their sums
Try all non-overlapping pairs and track maximum sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Pairs

Find all possible positions for both subarrays

Check Overlap

Ensure subarrays don't overlap

Track Maximum

Keep the pair with highest sum

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int firstLen, int secondLen) {
    int maxSum = INT_MIN;
    
    // Try firstLen subarray before secondLen subarray
    for (int i = 0; i <= numsSize - firstLen; i++) {
        int firstSum = 0;
        for (int k = i; k < i + firstLen; k++) {
            firstSum += nums[k];
        }
        for (int j = i + firstLen; j <= numsSize - secondLen; j++) {
            int secondSum = 0;
            for (int k = j; k < j + secondLen; k++) {
                secondSum += nums[k];
            }
            if (firstSum + secondSum > maxSum) {
                maxSum = firstSum + secondSum;
            }
        }
    }
    
    // Try secondLen subarray before firstLen subarray
    for (int i = 0; i <= numsSize - secondLen; i++) {
        int secondSum = 0;
        for (int k = i; k < i + secondLen; k++) {
            secondSum += nums[k];
        }
        for (int j = i + secondLen; j <= numsSize - firstLen; j++) {
            int firstSum = 0;
            for (int k = j; k < j + firstLen; k++) {
                firstSum += nums[k];
            }
            if (firstSum + secondSum > maxSum) {
                maxSum = firstSum + secondSum;
            }
        }
    }
    
    return maxSum;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        if (strlen(token) > 0) {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    int firstLen, secondLen;
    scanf("%d", &firstLen);
    scanf("%d", &secondLen);
    
    printf("%d\n", solution(nums, numsSize, firstLen, secondLen));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) pairs of starting positions × O(n) to check overlap and calculate sums

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track maximum, no extra data structures

✓ Linear Space

34.5K Views

Medium Frequency

~25 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 Pairs — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler