Skip to content
Related Articles

Related Articles

Maximize the subarray sum by choosing M subarrays of size K

Improve Article
Save Article
Like Article
  • Last Updated : 12 Nov, 2021

Given an array arr containing N positive integers, and two integers K and M, the task is to calculate the maximum sum of M subarrays of size K.

Example:

Input: arr[] = {1, 2, 1, 2, 6, 7, 5, 1}, M = 3, K = 2
Output: 33
Explanation: The three chosen subarrays are [2, 6], [6, 7] and [7, 5] respectively. So, sum: 8 +12 +13 = 33

Input: arr[] = {1, 4, 1, 0, 6, 7, 5, 9}, M = 4,, K = 5
Output: 76

 

Approach: The problem can be solved by precomputing the prefix sum till each index i which will tell us the sum of the subarray from 0 to i. Now this prefix sum can be used to find the sum of each subarray of size K, using the formula:

Subarray sum from i to j = Prefix sum till j – prefix Sum till i

After finding all subarrays sum, choose the maximum M subarray sums to calculate the answer. 
To solve this problem follow the below steps:

  1. Create a vector prefixSum in which each node represents the prefix sum till that index, and another vector subarraySum, to store all subarrays sum of size K.
  2. Now, run a loop from i=K to i=N and calculate the sum of each subarray using the formula subarraySum[i-K, i]=prefixSum[i]-prefixSum[i-K] and push it in vector subarraySum.
  3. Sort subarraySum in decreasing order and add the top M elements to get the answer.
  4. Print the answer according to the above observation.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate the maximum
// sum of M subarrays of size K
int maximumSum(vector<int>& arr, int M, int K)
{
    int N = arr.size();
    vector<int> prefixSum(N + 1, 0);
 
    // Calculating prefix sum
    for (int i = 1; i <= N; ++i) {
        prefixSum[i] = prefixSum[i - 1]
                       + arr[i - 1];
    }
 
    vector<int> subarraysSum;
 
    // Finding sum of each subarray of size K
    for (int i = K; i <= N; i++) {
        subarraysSum.push_back(
            prefixSum[i]
            - prefixSum[i - K]);
    }
 
    sort(subarraysSum.begin(),
         subarraysSum.end(),
         greater<int>());
 
    int sum = 0;
 
    // Selecting the M maximum sums
    // to calculate the answer
    for (int i = 0; i < M; ++i) {
        sum += subarraysSum[i];
    }
    return sum;
}
 
// Driver Code
int main()
{
    vector<int> arr = { 1, 4, 1, 0, 6, 7, 5, 9 };
    int M = 4, K = 5;
    cout << maximumSum(arr, M, K);
}

Java




// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to calculate the maximum
// sum of M subarrays of size K
static  int maximumSum(int []arr, int M, int K)
{
    int N = arr.length;
    int []prefixSum = new int[N + 1];
 
    // Calculating prefix sum
    for (int i = 1; i <= N; ++i) {
        prefixSum[i] = prefixSum[i - 1]
                       + arr[i - 1];
    }
 
    Vector<Integer> subarraysSum = new Vector<Integer>();
 
    // Finding sum of each subarray of size K
    for (int i = K; i <= N; i++) {
        subarraysSum.add(
            prefixSum[i]
            - prefixSum[i - K]);
    }
 
    Collections.sort(subarraysSum,Collections.reverseOrder());
 
    int sum = 0;
 
    // Selecting the M maximum sums
    // to calculate the answer
    for (int i = 0; i < M; ++i) {
        sum += subarraysSum.get(i);
    }
    return sum;
}
 
// Driver Code
public static void main(String[] args)
{
    int[] arr = { 1, 4, 1, 0, 6, 7, 5, 9 };
    int M = 4, K = 5;
    System.out.print(maximumSum(arr, M, K));
}
}
 
// This code is contributed by 29AjayKumar

Python3




# python program for the above approach
 
# Function to calculate the maximum
# sum of M subarrays of size K
def maximumSum(arr, M, K):
 
    N = len(arr)
    prefixSum = [0 for _ in range(N + 1)]
 
    # Calculating prefix sum
    for i in range(1, N+1):
        prefixSum[i] = prefixSum[i - 1] + arr[i - 1]
 
    subarraysSum = []
 
    # Finding sum of each subarray of size K
    for i in range(K, N+1):
        subarraysSum.append(prefixSum[i] - prefixSum[i - K])
 
    subarraysSum.sort()
    sum = 0
 
    # Selecting the M maximum sums
    # to calculate the answer
    for i in range(0, M):
        sum += subarraysSum[i]
 
    return sum
 
# Driver Code
if __name__ == "__main__":
 
    arr = [1, 4, 1, 0, 6, 7, 5, 9]
    M = 4
    K = 5
    print(maximumSum(arr, M, K))
 
    # This code is contributed by rakeshsahni

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG
{
// Function to calculate the maximum
// sum of M subarrays of size K
static  int maximumSum(int []arr, int M, int K)
{
    int N = arr.Length;
    int []prefixSum = new int[N + 1];
 
    // Calculating prefix sum
    for (int i = 1; i <= N; ++i) {
        prefixSum[i] = prefixSum[i - 1]
                       + arr[i - 1];
    }
     
    List<int> subarraysSum = new List<int>();
 
    // Finding sum of each subarray of size K
    for (int i = K; i <= N; i++) {
        subarraysSum.Add(
            prefixSum[i]
            - prefixSum[i - K]);
    }
     
    subarraysSum.Sort();
    subarraysSum.Reverse();
     
    int sum = 0;
 
    // Selecting the M maximum sums
    // to calculate the answer
    for (int i = 0; i < M; ++i) {
        sum += subarraysSum[i];
    }
    return sum;
}
 
// Driver Code
public static void Main()
{
    int[] arr = { 1, 4, 1, 0, 6, 7, 5, 9 };
    int M = 4, K = 5;
    Console.Write(maximumSum(arr, M, K));
}
}
 
// This code is contributed by Samim Hossain Mondal

Javascript




<script>
// Javascript code for the above approach
  
// Function to calculate the maximum
// sum of M subarrays of size K
function maximumSum(arr, M, K)
{
    var N = arr.length;
    var prefixSum = Array(N + 1).fill(0);
 
    // Calculating prefix sum
    for (var i = 1; i <= N; ++i) {
        prefixSum[i] = prefixSum[i - 1]
                       + arr[i - 1];
    }
    var subarraysSum = [];
    var t = 0;
 
    // Finding sum of each subarray of size K
    for (var i = K; i <= N; i++) {
        subarraysSum[t++] =
            (prefixSum[i] - prefixSum[i - K]);
    }
     
    subarraysSum.sort();
    subarraysSum.reverse();
    var sum = 0;
 
    // Selecting the M maximum sums
    // to calculate the answer
    for (var i = 0; i < M; ++i) {
        sum += subarraysSum[i];
    }
    return sum;
}
 
// Driver Code
var arr = [ 1, 4, 1, 0, 6, 7, 5, 9 ];
var M = 4, K = 5;
document.write(maximumSum(arr, M, K));
 
// This code is contributed by Samim Hossain Mondal
</script>

 
 

Output
76

 

Time Complexity: O(N)
Auxiliary Space: O(N)

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!