Related Articles

# Maximum Sum Alternating Subarray

• Difficulty Level : Basic
• Last Updated : 19 Jul, 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 ``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<

## 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``(sumSoFar, 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

 ``
Output:
`9`

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up