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

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

✓ Dynamic Programming with Precomputation

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

Use dynamic programming to precompute the best left subarray position for each index and the best right subarray position for each index. Then iterate through all possible middle positions and combine with precomputed optimal left and right positions.

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>
#include <string.h>

static int nums[20000];
static int numsSize;

int* maxSumOfThreeSubarrays(int k) {
    int n = numsSize;
    int max_sum = -1;
    static int best_result[3];
    int found = 0;
    
    // Try all possible combinations of three non-overlapping subarrays
    for (int i = 0; i <= n - 3*k; i++) {
        for (int j = i + k; j <= n - 2*k; j++) {
            for (int l = j + k; l <= n - k; l++) {
                // Calculate sum of three subarrays
                int sum1 = 0, sum2 = 0, sum3 = 0;
                for (int x = i; x < i + k; x++) sum1 += nums[x];
                for (int x = j; x < j + k; x++) sum2 += nums[x];
                for (int x = l; x < l + k; x++) sum3 += nums[x];
                int total = sum1 + sum2 + sum3;
                
                // Update if we found a better sum, or same sum but lexicographically smaller
                if (total > max_sum || (total == max_sum && (!found || 
                    i < best_result[0] || (i == best_result[0] && j < best_result[1]) || 
                    (i == best_result[0] && j == best_result[1] && l < best_result[2])))) {
                    max_sum = total;
                    best_result[0] = i;
                    best_result[1] = j;
                    best_result[2] = l;
                    found = 1;
                }
            }
        }
    }
    
    return best_result;
}

int main() {
    char line[100000];
    
    // Read first line (nums)
    if (fgets(line, sizeof(line), stdin) == NULL) return 1;
    
    // Parse numbers
    numsSize = 0;
    char* token = strtok(line, ",\n");
    while (token != NULL && numsSize < 20000) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",\n");
    }
    
    // Read second line (k)
    if (fgets(line, sizeof(line), stdin) == NULL) return 1;
    int k = atoi(line);
    
    int* result = maxSumOfThreeSubarrays(k);
    printf("%d,%d,%d\n", result[0], result[1], result[2]);
    
    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

Maximum Sum of 3 Non-Overlapping Subarrays - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming with Precomputation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler