Maximum sum subarray of even length
Given an array arr[] of N elements, the task is to find the maximum sum of any subarray of length X such that X > 0 and X % 2 = 0.
Examples:
Input: arr[] = {1, 2, 3}
Output: 5
{2, 3} is the required subarray.
Input: arr[] = {8, 9, -8, 9, 10}
Output: 20
{9, -8, 9, 10} is the required subarray.
Even though {8, 9, -8, 9, 10} has the maximum sum
but it is not of even length.
Approach: This problem is a variation of maximum subarray sum problem and can be solved using dynamic programming approach. Create an array dp[] where dp[i] will store the maximum sum of an even length subarray whose first element is arr[i]. Now the recurrence relation will be:
dp[i] = max((arr[i] + arr[i + 1]), (arr[i] + arr[i + 1] + dp[i + 2]))
This is because the maximum sum even length subarray starting with the element arr[i] can either be the sum of arr[i] and arr[i + 1] or it can be arr[i] + arr[i + 1] added with the maximum sum of even length subarray starting with arr[i + 2] i.e. dp[i + 2]. Take the maximum of these two.
In the end, the maximum value from the dp[] array will be the required answer.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int maxEvenLenSum( int arr[], int n)
{
if (n < 2)
return 0;
int dp[n] = { 0 };
dp[n - 1] = 0;
dp[n - 2] = arr[n - 2] + arr[n - 1];
for ( int i = n - 3; i >= 0; i--) {
dp[i] = arr[i] + arr[i + 1];
if (dp[i + 2] > 0)
dp[i] += dp[i + 2];
}
int maxSum = *max_element(dp, dp + n);
return maxSum;
}
int main()
{
int arr[] = { 8, 9, -8, 9, 10 };
int n = sizeof (arr) / sizeof ( int );
cout << maxEvenLenSum(arr, n);
return 0;
}
|
Java
import java.util.Arrays;
class GFG
{
static int maxEvenLenSum( int arr[], int n)
{
if (n < 2 )
return 0 ;
int []dp = new int [n];
dp[n - 1 ] = 0 ;
dp[n - 2 ] = arr[n - 2 ] + arr[n - 1 ];
for ( int i = n - 3 ; i >= 0 ; i--)
{
dp[i] = arr[i] + arr[i + 1 ];
if (dp[i + 2 ] > 0 )
dp[i] += dp[i + 2 ];
}
int maxSum = Arrays.stream(dp).max().getAsInt();
return maxSum;
}
public static void main(String[] args)
{
int arr[] = { 8 , 9 , - 8 , 9 , 10 };
int n = arr.length;
System.out.println(maxEvenLenSum(arr, n));
}
}
|
Python3
def maxEvenLenSum(arr, n):
if (n < 2 ):
return 0
dp = [ 0 for i in range (n)]
dp[n - 1 ] = 0
dp[n - 2 ] = arr[n - 2 ] + arr[n - 1 ]
for i in range (n - 3 , - 1 , - 1 ):
dp[i] = arr[i] + arr[i + 1 ]
if (dp[i + 2 ] > 0 ):
dp[i] + = dp[i + 2 ]
maxSum = max (dp)
return maxSum
arr = [ 8 , 9 , - 8 , 9 , 10 ]
n = len (arr)
print (maxEvenLenSum(arr, n))
|
C#
using System;
class GFG
{
static int MaxSum( int []arr)
{
int large = arr[0];
for ( int i = 1; i < arr.Length; i++)
{
if (large < arr[i])
large = arr[i];
}
return large;
}
static int maxEvenLenSum( int []arr, int n)
{
if (n < 2)
return 0;
int []dp = new int [n];
dp[n - 1] = 0;
dp[n - 2] = arr[n - 2] + arr[n - 1];
for ( int i = n - 3; i >= 0; i--)
{
dp[i] = arr[i] + arr[i + 1];
if (dp[i + 2] > 0)
dp[i] += dp[i + 2];
}
int maxSum = MaxSum(dp);
return maxSum;
}
public static void Main()
{
int []arr = { 8, 9, -8, 9, 10 };
int n = arr.Length;
Console.WriteLine(maxEvenLenSum(arr, n));
}
}
|
Javascript
<script>
function maxEvenLenSum(arr, n) {
if (n < 2)
return 0;
let dp = new Array(n).fill(0);
dp[n - 1] = 0;
dp[n - 2] = arr[n - 2] + arr[n - 1];
for (let i = n - 3; i >= 0; i--) {
dp[i] = arr[i] + arr[i + 1];
if (dp[i + 2] > 0)
dp[i] += dp[i + 2];
}
let maxSum = dp.sort((a, b) => b - a)[0];
return maxSum;
}
let arr = [8, 9, -8, 9, 10];
let n = arr.length;
document.write(maxEvenLenSum(arr, n));
</script>
|
Time complexity: O(n)
Space complexity: O(n)
Efficient approach : Space optimization O(1)
To optimize the space complexity of previous approach we using only two variables to keep track of the previous two subproblems instead of creating an array of size n to store all the subproblem solutions. This way, we can reduce the space complexity from O(n) to O(1).
Implementation Steps:
- Check if the array size is less than 2, return 0 if true.
- Initialize prevPrevSum to 0 and prevSum to arr[n-2] + arr[n-1], which represents the sum of the last two elements of the array.
- Traverse the array from the second-last index to the first index and compute the sum of every even length subarray that ends at the current index.
- Add the current element and the next element of the array to get the sum of the current even-length subarray.
- If the sum of the subarray two indices ahead is greater than 0, add it to the current subarray sum.
- Update prevPrevSum and prevSum with the previous subarray sums for further iterations.
- At last Return the maximum of prevSum and prevPrevSum.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int maxEvenLenSum( int arr[], int n)
{
if (n < 2)
return 0;
int prevPrevSum = 0, prevSum = arr[n - 2] + arr[n - 1], currSum;
for ( int i = n - 3; i >= 0; i--) {
currSum = arr[i] + arr[i + 1];
if (prevPrevSum > 0)
currSum += prevPrevSum;
prevPrevSum = prevSum;
prevSum = currSum;
}
return max(prevSum, prevPrevSum);
}
int main()
{
int arr[] = { 8, 9, -8, 9, 10 };
int n = sizeof (arr) / sizeof ( int );
cout << maxEvenLenSum(arr, n);
return 0;
}
|
Java
import java.util.*;
public class Main {
static int maxEvenLenSum( int arr[], int n) {
if (n < 2 )
return 0 ;
int prevPrevSum = 0 , prevSum = arr[n - 2 ] + arr[n - 1 ], currSum;
for ( int i = n - 3 ; i >= 0 ; i--) {
currSum = arr[i] + arr[i + 1 ];
if (prevPrevSum > 0 )
currSum += prevPrevSum;
prevPrevSum = prevSum;
prevSum = currSum;
}
return Math.max(prevSum, prevPrevSum);
}
public static void main(String[] args) {
int arr[] = { 8 , 9 , - 8 , 9 , 10 };
int n = arr.length;
System.out.println(maxEvenLenSum(arr, n));
}
}
|
Python3
def maxEvenLenSum(arr, n):
if n < 2 :
return 0
prevPrevSum = 0
prevSum = arr[n - 2 ] + arr[n - 1 ]
for i in range (n - 3 , - 1 , - 1 ):
currSum = arr[i] + arr[i + 1 ]
if prevPrevSum > 0 :
currSum + = prevPrevSum
prevPrevSum = prevSum
prevSum = currSum
return max (prevSum, prevPrevSum)
arr = [ 8 , 9 , - 8 , 9 , 10 ]
n = len (arr)
print (maxEvenLenSum(arr, n))
|
C#
using System;
class GFG {
static int maxEvenLenSum( int [] arr, int n)
{
if (n < 2)
return 0;
int prevPrevSum = 0,
prevSum = arr[n - 2] + arr[n - 1], currSum;
for ( int i = n - 3; i >= 0; i--) {
currSum = arr[i] + arr[i + 1];
if (prevPrevSum > 0)
currSum += prevPrevSum;
prevPrevSum = prevSum;
prevSum = currSum;
}
return Math.Max(prevSum, prevPrevSum);
}
static void Main()
{
int [] arr = { 8, 9, -8, 9, 10 };
int n = arr.Length;
Console.Write(maxEvenLenSum(arr, n));
}
}
|
Javascript
<script>
function maxEvenLenSum(arr, n) {
if (n < 2) {
return 0;
}
let prevPrevSum = 0;
let prevSum = arr[n - 2] + arr[n - 1];
let currSum;
for (let i = n - 3; i >= 0; i--) {
currSum = arr[i] + arr[i + 1];
if (prevPrevSum > 0) {
currSum += prevPrevSum;
}
prevPrevSum = prevSum;
prevSum = currSum;
}
return Math.max(prevSum, prevPrevSum);
}
const arr = [8, 9, -8, 9, 10];
const n = arr.length;
document.write(maxEvenLenSum(arr, n));
</script>
|
Output
20
Time complexity: O(n)
Auxiliary Space: O(1)
Last Updated :
20 Jul, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...