Maximize the subarray sum by choosing M subarrays of size K
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:
- 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.
- 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.
- Sort subarraySum in decreasing order and add the top M elements to get the answer.
- Print the answer according to the above observation.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int maximumSum(vector< int >& arr, int M, int K)
{
int N = arr.size();
vector< int > prefixSum(N + 1, 0);
for ( int i = 1; i <= N; ++i) {
prefixSum[i] = prefixSum[i - 1]
+ arr[i - 1];
}
vector< int > subarraysSum;
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;
for ( int i = 0; i < M; ++i) {
sum += subarraysSum[i];
}
return sum;
}
int main()
{
vector< int > arr = { 1, 4, 1, 0, 6, 7, 5, 9 };
int M = 4, K = 5;
cout << maximumSum(arr, M, K);
}
|
Java
import java.util.*;
class GFG{
static int maximumSum( int []arr, int M, int K)
{
int N = arr.length;
int []prefixSum = new int [N + 1 ];
for ( int i = 1 ; i <= N; ++i) {
prefixSum[i] = prefixSum[i - 1 ]
+ arr[i - 1 ];
}
Vector<Integer> subarraysSum = new Vector<Integer>();
for ( int i = K; i <= N; i++) {
subarraysSum.add(
prefixSum[i]
- prefixSum[i - K]);
}
Collections.sort(subarraysSum,Collections.reverseOrder());
int sum = 0 ;
for ( int i = 0 ; i < M; ++i) {
sum += subarraysSum.get(i);
}
return sum;
}
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));
}
}
|
Python3
def maximumSum(arr, M, K):
N = len (arr)
prefixSum = [ 0 for _ in range (N + 1 )]
for i in range ( 1 , N + 1 ):
prefixSum[i] = prefixSum[i - 1 ] + arr[i - 1 ]
subarraysSum = []
for i in range (K, N + 1 ):
subarraysSum.append(prefixSum[i] - prefixSum[i - K])
subarraysSum.sort()
sum = 0
for i in range ( 0 , M):
sum + = subarraysSum[i]
return sum
if __name__ = = "__main__" :
arr = [ 1 , 4 , 1 , 0 , 6 , 7 , 5 , 9 ]
M = 4
K = 5
print (maximumSum(arr, M, K))
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static int maximumSum( int []arr, int M, int K)
{
int N = arr.Length;
int []prefixSum = new int [N + 1];
for ( int i = 1; i <= N; ++i) {
prefixSum[i] = prefixSum[i - 1]
+ arr[i - 1];
}
List< int > subarraysSum = new List< int >();
for ( int i = K; i <= N; i++) {
subarraysSum.Add(
prefixSum[i]
- prefixSum[i - K]);
}
subarraysSum.Sort();
subarraysSum.Reverse();
int sum = 0;
for ( int i = 0; i < M; ++i) {
sum += subarraysSum[i];
}
return sum;
}
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));
}
}
|
Javascript
<script>
function maximumSum(arr, M, K)
{
var N = arr.length;
var prefixSum = Array(N + 1).fill(0);
for ( var i = 1; i <= N; ++i) {
prefixSum[i] = prefixSum[i - 1]
+ arr[i - 1];
}
var subarraysSum = [];
var t = 0;
for ( var i = K; i <= N; i++) {
subarraysSum[t++] =
(prefixSum[i] - prefixSum[i - K]);
}
subarraysSum.sort();
subarraysSum.reverse();
var sum = 0;
for ( var i = 0; i < M; ++i) {
sum += subarraysSum[i];
}
return sum;
}
var arr = [ 1, 4, 1, 0, 6, 7, 5, 9 ];
var M = 4, K = 5;
document.write(maximumSum(arr, M, K));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...