Max sum of M non-overlapping subarrays of size K

Last Updated : 24 Feb, 2025

Given an array and two numbers M and K. We need to find the max sum of sums of M subarrays of size K (non-overlapping) in the array. (Order of array remains unchanged). K is the size of subarrays and M is the count of subarray. It may be assumed that size of array is more than m*k. If total array size is not multiple of k, then we can take partial last array.

Examples :

Input: N = 7, M = 3, K = 1 , arr[] = {2, 10, 7, 18, 5, 33, 0};
Output: 61
Explanation: 3 Max sum subarrays of size 1 are 33, 18, 10

Input: N = 4, M = 2, K = 2 arr[] = {3, 2, 100, 1};
Output: 106
Explanation: 2 Max Sum Subarrays of size 2 are: (3, 2), (100, 1)

Naive Recursive Solution

We consider all subarray of size k, compute their sums and then make recursive calls based on two choices

Include the current subarray
Exclude the current subarray

The following are detailed steps.

We create a presum array, which contains in each index sum of all elements from ‘index‘ to ‘index + K’ in the given array. And size of the sum array will be n+1-k. We can compute presum[i] using presum[i-1] using window sliding.
Now if we include the subarray of size k, then we can not include any of the elements of that subarray again in any other subarray as it will create overlapping subarrays. So we make recursive call by excluding the k elements of included subarray.
if we exclude a subarray then we can use the next k-1 elements of that subarray in other subarrays so we will make recursive call by just excluding the first element of that subarray.
At last return the max(included sum, excluded sum).

Below is the implementation of the above approach:

C++

// C++ program to find Max sum of M non-overlapping // subarray of size K in an Array #include <bits/stdc++.h> using namespace std;  // calculating presum of array. presum[i] // is going to store prefix sum of subarray // of size k beginning with arr[i] void calculatePresumArray(int presum[],                 int arr[], int n, int k) {         for (int i=0; i<k; i++)        presum[0] += arr[i];      // store sum of array index i to i+k      // in presum array at index i of it.     for (int i = 1; i <= n - k; i++)         presum[i] += presum[i-1] + arr[i+k-1] -                                    arr[i-1]; }  // calculating maximum sum of m non overlapping array int maxSumMnonOverlappingSubarray(int presum[],               int m, int size, int k, int start) {     // if m is zero then no need any array     // of any size so return 0.     if (m == 0)         return 0;      // if start is greater then the size     // of presum array return 0.     if (start > size - 1)         return 0;      int mx = 0;      // if including subarray of size k     int includeMax = presum[start] +              maxSumMnonOverlappingSubarray(presum,                         m - 1, size, k, start + k);      // if excluding element and searching      // in all next possible subarrays     int excludeMax =              maxSumMnonOverlappingSubarray(presum,                             m, size, k, start + 1);      // return max     return max(includeMax, excludeMax); }  // Driver code int main() {     int arr[] = { 2, 10, 7, 18, 5, 33, 0 };     int n = sizeof(arr)/sizeof(arr[0]);           int m = 3, k = 1;      int presum[n + 1 - k] = { 0 };     calculatePresumArray(presum, arr, n, k);      // resulting presum array will have a size = n+1-k     cout << maxSumMnonOverlappingSubarray(presum,                                m, n + 1 - k, k, 0);      return 0; }

Java

// Java program to find Max sum  // of M non-overlapping subarray // of size K in an Array  import java.io.*;  class GFG  { // calculating presum of array.  // presum[i] is going to store  // prefix sum of subarray of  // size k beginning with arr[i] static void calculatePresumArray(int presum[],                                  int arr[],                                   int n, int k) {      for (int i = 0; i < k; i++)     presum[0] += arr[i];      // store sum of array index i to i+k      // in presum array at index i of it.     for (int i = 1; i <= n - k; i++)      presum[i] += presum[i - 1] + arr[i + k - 1] -                                   arr[i - 1]; }  // calculating maximum sum of // m non overlapping array static int maxSumMnonOverlappingSubarray(int presum[],                                          int m, int size,                                           int k, int start) {     // if m is zero then no need      // any array of any size so     // return 0.     if (m == 0)         return 0;      // if start is greater then the      // size of presum array return 0.     if (start > size - 1)         return 0;      int mx = 0;      // if including subarray of size k     int includeMax = presum[start] +              maxSumMnonOverlappingSubarray(presum,                       m - 1, size, k, start + k);      // if excluding element and searching      // in all next possible subarrays     int excludeMax =              maxSumMnonOverlappingSubarray(presum,                           m, size, k, start + 1);      // return max     return Math.max(includeMax, excludeMax); }  // Driver code public static void main (String[] args)  {     int arr[] = { 2, 10, 7, 18, 5, 33, 0 };     int n = arr.length;     int m = 3, k = 1;     int presum[] = new int[n + 1 - k] ;     calculatePresumArray(presum, arr, n, k);          // resulting presum array     // will have a size = n+1-k     System.out.println(maxSumMnonOverlappingSubarray(presum,                                         m, n + 1 - k, k, 0)); } }

Python

# Python3 program to find max sum of M non-overlapping # subarrays of size K in an array  # Function to calculate prefix sum of the array def calculatePresumArray(presum, arr, n, k):     for i in range(k):         presum[0] += arr[i]      # Store sum of subarray starting at index i     for i in range(1, n - k + 1):         presum[i] = presum[i - 1] + arr[i + k - 1] - arr[i - 1]  # Function to calculate maximum sum of M non-overlapping subarrays def maxSumMnonOverlappingSubarray(presum, m, size, k, start):     if m == 0:         return 0      if start > size - 1:         return 0      # Include current subarray     includeMax = presum[start] + maxSumMnonOverlappingSubarray(presum, m - 1, size, k, start + k)      # Exclude current subarray and check next possibility     excludeMax = maxSumMnonOverlappingSubarray(presum, m, size, k, start + 1)      return max(includeMax, excludeMax)  # Driver function if __name__ == "__main__":     arr = [2, 10, 7, 18, 5, 33, 0]     n = len(arr)     m, k = 3, 1      # Initialize prefix sum array     presum = [0 for _ in range(n + 1 - k)]     calculatePresumArray(presum, arr, n, k)      # Compute and print maximum sum of M non-overlapping subarrays     print(maxSumMnonOverlappingSubarray(presum, m, n + 1 - k, k, 0))

// C# program to find Max sum of M // non-overlapping subarray of size  // K in an Array using System;  class GFG {          // calculating presum of array.      // presum[i] is going to store      // prefix sum of subarray of      // size k beginning with arr[i]     static void calculatePresumArray(int []presum,                           int []arr, int n, int k)     {          for (int i = 0; i < k; i++)         presum[0] += arr[i];              // store sum of array index i to i+k          // in presum array at index i of it.         for (int i = 1; i <= n - k; i++)          presum[i] += presum[i - 1] + arr[i + k - 1]                                       - arr[i - 1];     }          // calculating maximum sum of     // m non overlapping array     static int maxSumMnonOverlappingSubarray(                      int []presum, int m, int size,                                    int k, int start)     {                  // if m is zero then no need          // any array of any size so         // return 0.         if (m == 0)             return 0;              // if start is greater then the          // size of presum array return 0.         if (start > size - 1)             return 0;              //int mx = 0;              // if including subarray of size k         int includeMax = presum[start] +                  maxSumMnonOverlappingSubarray(presum,                           m - 1, size, k, start + k);              // if excluding element and searching          // in all next possible subarrays         int excludeMax =                  maxSumMnonOverlappingSubarray(presum,                               m, size, k, start + 1);              // return max         return Math.Max(includeMax, excludeMax);     }          // Driver code     public static void Main ()      {         int []arr = { 2, 10, 7, 18, 5, 33, 0 };         int n = arr.Length;         int m = 3, k = 1;         int []presum = new int[n + 1 - k] ;         calculatePresumArray(presum, arr, n, k);                  // resulting presum array         // will have a size = n+1-k         Console.WriteLine(               maxSumMnonOverlappingSubarray(presum,                               m, n + 1 - k, k, 0));     } }

JavaScript

// Javascript program to find Max sum  // of M non-overlapping subarray // of size K in an Array  // calculating presum of array.  // presum[i] is going to store  // prefix sum of subarray of  // size k beginning with arr[i] function calculatePresumArray(presum,arr,n,k) {     for (let i = 0; i < k; i++)         presum[0] += arr[i];        // store sum of array index i to i+k      // in presum array at index i of it.     for (let i = 1; i <= n - k; i++)          presum[i] += presum[i - 1] + arr[i + k - 1] -                                   arr[i - 1];             }  // calculating maximum sum of // m non overlapping array function maxSumMnonOverlappingSubarray(presum,m,size,k,start) {     // if m is zero then no need      // any array of any size so     // return 0.     if (m == 0)         return 0;        // if start is greater then the      // size of presum array return 0.     if (start > size - 1)         return 0;        let mx = 0;        // if including subarray of size k     let includeMax = presum[start] +              maxSumMnonOverlappingSubarray(presum,                       m - 1, size, k, start + k);        // if excluding element and searching      // in all next possible subarrays     let excludeMax =              maxSumMnonOverlappingSubarray(presum,                           m, size, k, start + 1);        // return max     return Math.max(includeMax, excludeMax); }  // Driver code let arr=[2, 10, 7, 18, 5, 33, 0]; let n = arr.length; let m = 3, k = 1; let presum = new Array(n + 1 - k) ; for(let i = 0; i < presum.length; i++) {     presum[i] = 0; } calculatePresumArray(presum, arr, n, k);  // resulting presum array // will have a size = n+1-k console.log(maxSumMnonOverlappingSubarray(presum,                                                  m, n + 1 - k, k, 0));

Output

Time complexity: O(2^m * n), as recursion explores all possible ways to pick m non-overlapping subarrays, leading to O(2^m) recursive calls and calculating the prefix sum takes O(n) time.
Space complexity: O(n), The prefix sum array requires O(n) space and the recursion stack depth can go up to O(m) in the worst case.

Using Dynamic Programming

The idea is to maximize the sum of M non-overlapping subarrays of size K using dynamic programming with memoization. We have two choices at every index: either take the current subarray (of size K) and move forward or skip it and check the next element. We store results in a memoization table to avoid recomputation. The final result is the maximum sum obtained by selecting M such subarrays optimally.

Steps to implement the above idea:

Define a recursive function to determine the maximum sum of M non-overlapping subarrays of size K.
Handle base cases: If all M subarrays are selected, return 0. If the index exceeds the valid range, return a minimum possible value.
Use memoization to store previously computed results to avoid redundant calculations.
Calculate the sum of the current subarray of size K and explore two choices—either take this subarray and move ahead by K steps or skip the current element and move forward by one step.
Store the maximum of both choices in the memoization table and return it.
Implement a wrapper function to initialize the memoization table and call the recursive function.

Below is the implementation of the above approach:

C++

// Approach: DP with memoization // Language: C++  #include <bits/stdc++.h> using namespace std;  // Recursive function to find the maximum sum of M non-overlapping subarrays int solve(vector<int> &arr, int n, int m, int k, int idx, vector<vector<int>> &memo) {     // Base case: If we have selected M subarrays, return 0     if (m == 0) {         return 0;     }          // If the index is beyond the valid range, return a minimum value     if (idx > n - k) {         return INT_MIN;     }          // If the result is already computed, return it from memo     if (memo[idx][m] != -1) {         return memo[idx][m];     }          // Calculate sum of the current subarray of size K     int sum = accumulate(arr.begin() + idx, arr.begin() + idx + k, 0);          // Option 1: Take the current subarray and move to the next non-overlapping subarray     int take = sum + solve(arr, n, m - 1, k, idx + k, memo);          // Option 2: Skip the current element and check the next index     int skip = solve(arr, n, m, k, idx + 1, memo);          // Store the maximum of both choices in memo and return it     return memo[idx][m] = max(take, skip); }  // Function to initialize memoization table and call the recursive function int maxSumMSubarrays(vector<int> &arr, int n, int m, int k) {     vector<vector<int>> memo(n, vector<int>(m + 1, -1)); // Initialize memo table with -1     return solve(arr, n, m, k, 0, memo); }  int main() {     vector<int> arr = {2, 10, 7, 18, 5, 33, 0}; // Input array     int n = arr.size(), m = 3, k = 1; // Define number of subarrays and their size     cout << maxSumMSubarrays(arr, n, m, k) << endl; // Output the result     return 0; }

Java

// Approach: DP with memoization // Language: Java  import java.util.*;  class GfG {     // Recursive function to find the maximum sum of M non-overlapping subarrays     static int solve(List<Integer> arr, int n, int m, int k, int idx, int[][] memo) {         // Base case: If we have selected M subarrays, return 0         if (m == 0) {             return 0;         }          // If the index is beyond the valid range, return a minimum value         if (idx > n - k) {             return Integer.MIN_VALUE;         }          // If the result is already computed, return it from memo         if (memo[idx][m] != -1) {             return memo[idx][m];         }          // Calculate sum of the current subarray of size K         int sum = 0;         for (int i = idx; i < idx + k; i++) {             sum += arr.get(i);         }          // Option 1: Take the current subarray and move to the next non-overlapping subarray         int take = sum + solve(arr, n, m - 1, k, idx + k, memo);          // Option 2: Skip the current element and check the next index         int skip = solve(arr, n, m, k, idx + 1, memo);          // Store the maximum of both choices in memo and return it         return memo[idx][m] = Math.max(take, skip);     }      // Function to initialize memoization table and call the recursive function     static int maxSumMSubarrays(List<Integer> arr, int n, int m, int k) {         int[][] memo = new int[n][m + 1]; // Initialize memo table with -1         for (int[] row : memo) {             Arrays.fill(row, -1);         }         return solve(arr, n, m, k, 0, memo);     }      public static void main(String[] args) {         List<Integer> arr = Arrays.asList(2, 10, 7, 18, 5, 33, 0); // Input array         int n = arr.size(), m = 3, k = 1; // Define number of subarrays and their size         System.out.println(maxSumMSubarrays(arr, n, m, k)); // Output the result     } }

Python

# Approach: DP with memoization # Language: Python  def solve(arr, n, m, k, idx, memo):     # Base case: If we have selected M subarrays, return 0     if m == 0:         return 0          # If the index is beyond the valid range, return a minimum value     if idx > n - k:         return float('-inf')          # If the result is already computed, return it from memo     if memo[idx][m] != -1:         return memo[idx][m]          # Calculate sum of the current subarray of size K     sum_subarray = sum(arr[idx:idx + k])          # Option 1: Take the current subarray and move to the next non-overlapping subarray     take = sum_subarray + solve(arr, n, m - 1, k, idx + k, memo)          # Option 2: Skip the current element and check the next index     skip = solve(arr, n, m, k, idx + 1, memo)          # Store the maximum of both choices in memo and return it     memo[idx][m] = max(take, skip)     return memo[idx][m]  def max_sum_m_subarrays(arr, n, m, k):     memo = [[-1] * (m + 1) for _ in range(n)]  # Initialize memo table with -1     return solve(arr, n, m, k, 0, memo)  if __name__ == "__main__":     arr = [2, 10, 7, 18, 5, 33, 0]  # Input array     n, m, k = len(arr), 3, 1  # Define number of subarrays and their size     print(max_sum_m_subarrays(arr, n, m, k))  # Output the result

// Approach: DP with memoization // Language: C#  using System; using System.Collections.Generic;  class GfG {     // Recursive function to find the maximum sum of M non-overlapping subarrays     static int Solve(List<int> arr, int n, int m, int k, int idx, int[,] memo) {         // Base case: If we have selected M subarrays, return 0         if (m == 0) {             return 0;         }          // If the index is beyond the valid range, return a minimum value         if (idx > n - k) {             return int.MinValue;         }          // If the result is already computed, return it from memo         if (memo[idx, m] != -1) {             return memo[idx, m];         }          // Calculate sum of the current subarray of size K         int sum = 0;         for (int i = idx; i < idx + k; i++) {             sum += arr[i];         }          // Option 1: Take the current subarray and move to the next non-overlapping subarray         int take = sum + Solve(arr, n, m - 1, k, idx + k, memo);          // Option 2: Skip the current element and check the next index         int skip = Solve(arr, n, m, k, idx + 1, memo);          // Store the maximum of both choices in memo and return it         return memo[idx, m] = Math.Max(take, skip);     }      // Function to initialize memoization table and call the recursive function     static int MaxSumMSubarrays(List<int> arr, int n, int m, int k) {         int[,] memo = new int[n, m + 1]; // Initialize memo table with -1         for (int i = 0; i < n; i++) {             for (int j = 0; j <= m; j++) {                 memo[i, j] = -1;             }         }         return Solve(arr, n, m, k, 0, memo);     }      public static void Main() {         List<int> arr = new List<int> { 2, 10, 7, 18, 5, 33, 0 }; // Input array         int n = arr.Count, m = 3, k = 1; // Define number of subarrays and their size         Console.WriteLine(MaxSumMSubarrays(arr, n, m, k)); // Output the result     } }

JavaScript

// Approach: DP with memoization // Language: JavaScript  function solve(arr, n, m, k, idx, memo) {     // Base case: If we have selected M subarrays, return 0     if (m === 0) {         return 0;     }          // If the index is beyond the valid range, return a minimum value     if (idx > n - k) {         return Number.MIN_SAFE_INTEGER;     }          // If the result is already computed, return it from memo     if (memo[idx][m] !== -1) {         return memo[idx][m];     }          // Calculate sum of the current subarray of size K     let sumSubarray = arr.slice(idx, idx + k).reduce((a, b) => a + b, 0);          // Option 1: Take the current subarray and move to the next non-overlapping subarray     let take = sumSubarray + solve(arr, n, m - 1, k, idx + k, memo);          // Option 2: Skip the current element and check the next index     let skip = solve(arr, n, m, k, idx + 1, memo);          // Store the maximum of both choices in memo and return it     return memo[idx][m] = Math.max(take, skip); }  function maxSumMSubarrays(arr, n, m, k) {     let memo = Array.from({ length: n }, () => Array(m + 1).fill(-1)); // Initialize memo table with -1     return solve(arr, n, m, k, 0, memo); }  let arr = [2, 10, 7, 18, 5, 33, 0]; // Input array let n = arr.length, m = 3, k = 1; // Define number of subarrays and their size console.log(maxSumMSubarrays(arr, n, m, k)); // Output the result

Output

Time Complexity: O(N * M) since each state (idx, m) is computed once and stored in memoization.
Space Complexity: O(N * M) due to the memoization table storing results for N indices and M subarrays.

Maximum sum two non-overlapping subarrays of given size

kddeepak

Improve

Article Tags :

Practice Tags :

Max sum of M non-overlapping subarrays of size K

Naive Recursive Solution

Using Dynamic Programming

Similar Reads