Sum of K Subarrays With Length at Least M

Sum of K Subarrays With Length at Least M - Problem

You're tasked with finding the maximum possible sum by selecting exactly k non-overlapping subarrays from an integer array, where each selected subarray must have a length of at least m elements.

Given an integer array nums and two integers k and m, you need to strategically choose k subarrays that:

Do not overlap with each other
Each has a length ≥ m
Together produce the maximum possible sum

Example: If nums = [1, 2, 1, 2, 6, 7, 5, 1], k = 2, and m = 2, you might choose subarrays [2, 1, 2] (sum = 5) and [6, 7] (sum = 13) for a total of 18.

This problem combines dynamic programming with subarray optimization - you'll need to consider all possible ways to partition the array while maximizing the sum!

Input & Output

example_1.py — Basic Case

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

› Output: 18

💡 Note: Choose subarrays [2, 1, 2] (indices 1-3, sum=5) and [6, 7, 5] (indices 4-6, sum=18). Total: 5 + 13 = 18. Alternative: [1, 2] (sum=3) and [6, 7, 5] (sum=18) gives total 21, but [2, 6, 7] (sum=15) and [5, 1] (sum=6) gives 21 as well.

example_2.py — Minimum Length

$ Input: nums = [5, -2, 4, -1, 3], k = 2, m = 1

› Output: 8

💡 Note: With minimum length 1, we can choose single elements. Optimal: [5] (sum=5) and [4, -1, 3] (sum=6), total = 11. Or [5] and [4] for total = 9. Best is [5] and [3] for total = 8.

example_3.py — Edge Case

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

› Output: 4

💡 Note: Only one way to select 2 non-overlapping subarrays of length ≥ 2: [1,1] (sum=2) and [1,1] (sum=2). Total = 4.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ k ≤ 100
1 ≤ m ≤ nums.length
-10⁴ ≤ nums[i] ≤ 10⁴
k × m ≤ nums.length (must be possible to select k non-overlapping subarrays)

Visualization

Tap to expand

Understanding the Visualization

Survey Properties

Build prefix sums to quickly calculate any property segment value

Decision Points

At each house, decide: skip it or start a new property investment here

Try All Sizes

If starting investment, consider all valid lengths (m to end of street)

Memoize Results

Cache results for (position, remaining_investments) to avoid recalculation

Key Takeaway

🎯 Key Insight: The problem is solved optimally using dynamic programming with memoization, where we cache results for each (position, remaining_subarrays) state and use prefix sums for efficient range sum queries.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses dynamic programming with memoization combined with prefix sums for efficient subarray sum calculation. Key insight: at each position, decide whether to skip or start a subarray of various lengths, using memoization to cache overlapping subproblems with state (index, remaining_k).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization	O(n² × k × m)	O(n × k)	Optimize brute force using memoization to cache overlapping subproblems

Dynamic Programming with Memoization — Algorithm Steps

Build prefix sum array for O(1) subarray sum queries
Create memoization table for (index, remaining_k) states
Use the same recursive logic as brute force
Before computing, check if result is already cached
Store computed results in memo table before returning

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create empty memo table and prefix sums

First calls

Calculate and store initial subproblems

Cache hits

Reuse previously computed results

Build solution

Combine cached results to find optimal answer

Code -

solution.c — C

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

#define MAX_N 1000
#define MAX_MEMO 100000

typedef struct {
    int index;
    int remainingK;
    long long value;
} MemoEntry;

static long long prefix[MAX_N + 1];
static MemoEntry memo[MAX_MEMO];
static int memoSize = 0;

long long getSum(int start, int end) {
    return prefix[end + 1] - prefix[start];
}

long long findMemo(int index, int remainingK) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].index == index && memo[i].remainingK == remainingK) {
            return memo[i].value;
        }
    }
    return LLONG_MIN - 1; // Not found marker
}

void addMemo(int index, int remainingK, long long value) {
    if (memoSize < MAX_MEMO) {
        memo[memoSize].index = index;
        memo[memoSize].remainingK = remainingK;
        memo[memoSize].value = value;
        memoSize++;
    }
}

long long solve(int* nums, int n, int index, int remainingK, int m) {
    if (remainingK == 0) return 0;
    if (index >= n || n - index < remainingK * m) {
        return LLONG_MIN;
    }
    
    long long cached = findMemo(index, remainingK);
    if (cached != LLONG_MIN - 1) return cached;
    
    // Option 1: Skip
    long long maxSum = solve(nums, n, index + 1, remainingK, m);
    
    // Option 2: Start subarray
    for (int length = m; length <= n - index; length++) {
        long long currentSum = getSum(index, index + length - 1);
        long long remainingSum = solve(nums, n, index + length, remainingK - 1, m);
        if (remainingSum != LLONG_MIN) {
            if (currentSum + remainingSum > maxSum) {
                maxSum = currentSum + remainingSum;
            }
        }
    }
    
    addMemo(index, remainingK, maxSum);
    return maxSum;
}

long long maxSumOfKSubarrays(int* nums, int n, int k, int m) {
    // Build prefix sum
    prefix[0] = 0;
    for (int i = 0; i < n; i++) {
        prefix[i + 1] = prefix[i] + nums[i];
    }
    
    memoSize = 0;
    long long result = solve(nums, n, 0, k, m);
    return result == LLONG_MIN ? 0 : result;
}

int main() {
    int nums[] = {1,2,1,2,6,7,5,1};
    int n = 8, k = 2, m = 2;
    printf("%lld\n", maxSumOfKSubarrays(nums, n, k, m));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × k × m)

n×k states, each state tries O(n×m) subarray options

⚠ Quadratic Growth

Space Complexity

O(n × k)

Memoization table size plus prefix sum array

⚡ Linearithmic Space

28.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

Dynamic Programming with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler