Maximum Sum Alternating Subarray (original) (raw)

Last Updated : 18 Nov, 2021

Given an array arr[] of size N, the task is to find the maximum alternating sum of a subarray possible for a given array.

Alternating Subarray Sum: Considering a subarray {arr[i], arr[j]}, alternating sum of the subarray is arr[i] - arr[i + 1] + arr[i + 2] - ........ (+ / -) arr[j].

Examples:

Input: arr[] = {-4, -10, 3, 5}
Output: 9
Explanation: Subarray {arr[0], arr[2]} = {-4, -10, 3}. Therefore, the sum of this subarray is 9.

Input: arr[] = {-1, 2, -1, 4, 7}
Output: 7

Approach: The given problem can be solved by using Dynamic Programming. Follow the steps below to solve the problem:

Initialize a variable, say sum as 0, which will hold a maximum alternating subarray sum and a variable, say sumSoFar, to store the sum of subarrays starting from even indices in the 1st loop and the sum starting from odd indices, in the 2nd loop.
In every iteration of both the loops, update sum as max(sum, sumSoFar).
Finally, return the maximum alternating sum stored in the sum variable.

Below is the implementation of the above approach:

C++ `

// C++ implementation for the above approach #include <bits/stdc++.h> using namespace std;

// Function to find the maximum alternating // sum of a subarray for the given array int alternatingSum(int arr[],int n) { int sum = 0; int sumSoFar = 0;

// Traverse the array for (int i = 0; i < n; i++) {

// Store sum of subarrays
// starting at even indices
if (i % 2 == 1) {

  sumSoFar -= arr[i];
}
else {

  sumSoFar = max(
    sumSoFar + arr[i], arr[i]);
}

// Update sum
sum = max(sum, sumSoFar);

}

sumSoFar = 0;

// Traverse the array for (int i = 1; i < n; i++) {

// Store sum of subarrays
// starting at odd indices
if (i % 2 == 0) {
  sumSoFar -= arr[i];
}
else {
  sumSoFar = max(
    sumSoFar + arr[i], arr[i]);
}

// Update sum
sum = max(sum, sumSoFar);

} return sum; }

// Driver code int main() {

// Given Input int arr[] ={ -4, -10, 3, 5 }; int n = sizeof(arr)/sizeof(arr[0]);

// Function call int ans = alternatingSum(arr,n);

cout<<ans<<endl; return 0; }

// This code is contributed by Potta Lokesh

Java

// Java implementation for the above approach

import java.io.*;

class GFG {

// Function to find the maximum alternating
// sum of a subarray for the given array
public static int alternatingSum(int[] arr)
{
    int sum = 0;
    int sumSoFar = 0;

    // Traverse the array
    for (int i = 0; i < arr.length; i++) {

        // Store sum of subarrays
        // starting at even indices
        if (i % 2 == 1) {

            sumSoFar -= arr[i];
        }
        else {

            sumSoFar = Math.max(
                sumSoFar + arr[i], arr[i]);
        }

        // Update sum
        sum = Math.max(sum, sumSoFar);
    }

    sumSoFar = 0;

    // Traverse the array
    for (int i = 1; i < arr.length; i++) {

        // Store sum of subarrays
        // starting at odd indices
        if (i % 2 == 0) {
            sumSoFar -= arr[i];
        }
        else {
            sumSoFar = Math.max(
                sumSoFar + arr[i], arr[i]);
        }

        // Update sum
        sum = Math.max(sum, sumSoFar);
    }
    return sum;
}

// Driver code
public static void main(String[] args)
{

    // Given Input
    int arr[] = new int[] { -4, -10, 3, 5 };

    // Function call
    int ans = alternatingSum(arr);

    System.out.println(ans);
}

}

Python3

Python implementation for the above approach

Function to find the maximum alternating

sum of a subarray for the given array

def alternatingSum(arr, n): sum_ = 0 sumSoFar = 0

# Traverse the array
for i in range(n):
  
  # Store sum of subarrays
   # starting at even indices
    if i % 2 == 1:
        sumSoFar -= arr[i]
    else:
        sumSoFar = max(arr[i], sumSoFar + arr[i])
        
        # Update sum
    sum_ = max(sum_, sumSoFar)

sumSoFar = 0

# Traverse array
for i in range(1, n):
  
  # Store sum of subarrays
  # starting at odd indices
    if i % 2 == 0:
        sumSoFar -= arr[i]
    else:
        sumSoFar = max(arr[i], sumSoFar + arr[i])
    sum_ = max(sum_, sumSoFar)
    
    # update sum
return sum_

given array

arr = [-4, -10, 3, 5] n = len(arr)

return sum

ans = alternatingSum(arr, n) print(ans)

This code is contributed by Parth Manchanda

C#

// C# implementation for the above approach using System; using System.Collections.Generic;

class GFG{

// Function to find the maximum alternating // sum of a subarray for the given array static int alternatingSum(int []arr,int n) { int sum = 0; int sumSoFar = 0;

// Traverse the array
for(int i = 0; i < n; i++)
{

    // Store sum of subarrays
    // starting at even indices
    if (i % 2 == 1)
    {
        sumSoFar -= arr[i];
    }
    else 
    {
        sumSoFar = Math.Max(
        sumSoFar + arr[i], arr[i]);
    }
    
    // Update sum
    sum = Math.Max(sum, sumSoFar);
}

sumSoFar = 0;

// Traverse the array
for(int i = 1; i < n; i++)
{

    // Store sum of subarrays
    // starting at odd indices
    if (i % 2 == 0)
    {
        sumSoFar -= arr[i];
    }
    else 
    {
        sumSoFar = Math.Max(
        sumSoFar + arr[i], arr[i]);
    }
    
    // Update sum
    sum = Math.Max(sum, sumSoFar);
}
return sum;

}

// Driver code public static void Main() {

// Given Input
int []arr = { -4, -10, 3, 5 };
int n = arr.Length;

// Function call
int ans = alternatingSum(arr,n);

Console.Write(ans);

} }

// This code is contributed by SURENDRA_GANGWAR

JavaScript

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