Maximum Sum of 3 Non-Overlapping Subarrays

Maximum Sum of 3 Non-Overlapping Subarrays - Problem

You're given an integer array nums and an integer k. Your task is to find three non-overlapping subarrays of length k that have the maximum total sum.

Return the result as a list of starting indices (0-indexed) of these three subarrays. If multiple valid answers exist with the same maximum sum, return the lexicographically smallest one.

Key constraints:

The three subarrays cannot overlap
Each subarray must have exactly k elements
You need the indices of where each subarray starts
Prefer smaller indices when there are ties

Example: For nums = [1,2,1,2,6,7,5,1] and k = 2, the answer is [0,3,5] because subarrays [1,2], [2,6], and [7,5] give the maximum sum of 22.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,2,1,2,6,7,5,1], k = 2

› Output: [0, 3, 5]

💡 Note: Subarrays [1,2] at index 0 (sum=3), [2,6] at index 3 (sum=8), and [7,5] at index 5 (sum=12) give maximum total sum of 23.

example_2.py — Tie Breaking

$ Input: nums = [1,2,1,2,1,2,1,2,1], k = 2

› Output: [0, 2, 4]

💡 Note: Multiple combinations give the same sum, but [0,2,4] is lexicographically smallest. Subarrays [1,2], [1,2], [1,2] each sum to 3, total = 9.

example_3.py — Minimum Length

$ Input: nums = [4,3,2,1,7,6], k = 1

› Output: [0, 4, 5]

💡 Note: With k=1, we pick individual elements. Elements 4, 7, 6 at indices [0,4,5] give maximum sum of 17.

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
1 ≤ nums[i] ≤ 10⁶
1 ≤ k ≤ floor(nums.length / 3)
The array must have space for at least 3 non-overlapping subarrays of length k

Visualization

Tap to expand

Understanding the Visualization

Calculate Block Values

Determine the total value of each possible k-seat block using sliding window

Precompute Left Options

For each position, know the best left block that doesn't interfere

Precompute Right Options

For each position, know the best right block that doesn't interfere

Optimize Middle Block

Try each middle block and combine with precomputed optimal left/right blocks

Key Takeaway

🎯 Key Insight: By precomputing the optimal left and right subarray positions for each index, we transform a cubic time problem into a linear one. The middle position iteration becomes the only variable, while left and right positions are optimally determined through dynamic programming.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal approach uses dynamic programming with precomputation to achieve O(n) time complexity. We precompute the best left and right subarray positions for each index, then iterate through middle positions to find the optimal combination. This reduces the problem from O(n³) brute force to an elegant linear solution.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Precomputation	O(n)	O(n)	Precompute optimal left and right positions for efficient lookup

Dynamic Programming with Precomputation — Algorithm Steps

Calculate all subarray sums of length k using sliding window
Precompute left array: for each position, store index of best left subarray ending before this position
Precompute right array: for each position, store index of best right subarray starting after this position
Iterate through all possible middle positions and combine with optimal left and right
Return the combination with maximum sum (lexicographically smallest for ties)

Visualization

Tap to expand

Step-by-Step Walkthrough

Compute Subarray Sums

Use sliding window to get all k-length subarray sums

Precompute Left Array

For each position, store the best left subarray index

Precompute Right Array

For each position, store the best right subarray index

Find Optimal Middle

Try each middle position with precomputed left and right

Code -

solution.c — C

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

int* maxSumOfThreeSubarrays(int* nums, int numsSize, int k) {
    // Step 1: Calculate all subarray sums
    int sumsSize = numsSize - k + 1;
    int* sums = (int*)malloc(sumsSize * sizeof(int));
    int windowSum = 0;
    for (int i = 0; i < k; i++) {
        windowSum += nums[i];
    }
    sums[0] = windowSum;
    
    for (int i = k; i < numsSize; i++) {
        windowSum += nums[i] - nums[i - k];
        sums[i - k + 1] = windowSum;
    }
    
    // Step 2: Precompute best left subarray indices
    int* left = (int*)malloc(sumsSize * sizeof(int));
    int bestLeftIdx = 0;
    for (int i = 0; i < sumsSize; i++) {
        if (sums[i] > sums[bestLeftIdx]) {
            bestLeftIdx = i;
        }
        left[i] = bestLeftIdx;
    }
    
    // Step 3: Precompute best right subarray indices
    int* right = (int*)malloc(sumsSize * sizeof(int));
    int bestRightIdx = sumsSize - 1;
    for (int i = sumsSize - 1; i >= 0; i--) {
        if (sums[i] >= sums[bestRightIdx]) {
            bestRightIdx = i;
        }
        right[i] = bestRightIdx;
    }
    
    // Step 4: Find optimal middle position
    int maxSum = 0;
    int* result = (int*)malloc(3 * sizeof(int));
    result[0] = 0; result[1] = k; result[2] = 2 * k;
    
    for (int mid = k; mid < sumsSize - k; mid++) {
        int leftIdx = left[mid - k];
        int rightIdx = right[mid + k];
        int totalSum = sums[leftIdx] + sums[mid] + sums[rightIdx];
        
        if (totalSum > maxSum) {
            maxSum = totalSum;
            result[0] = leftIdx; result[1] = mid; result[2] = rightIdx;
        }
    }
    
    free(sums);
    free(left);
    free(right);
    return result;
}

int main() {
    int nums[] = {1, 2, 1, 2, 6, 7, 5, 1};
    int k = 2;
    int* result = maxSumOfThreeSubarrays(nums, 8, k);
    printf("[%d,%d,%d]\n", result[0], result[1], result[2]);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Three separate O(n) passes: compute sums, precompute left/right arrays, find optimal middle

✓ Linear Growth

Space Complexity

O(n)

Space for subarray sums and left/right precomputed arrays

⚡ Linearithmic Space

42.8K Views

High Frequency

~18 min Avg. Time

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

Dynamic Programming with Precomputation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler