Given an array **arr[]** of size **N**, consisting of positive and negative integers, the task is to find the longest alternating subsequence(i.e. the sign of every element is opposite to that of its previous element) from the given array which has the maximum sum.**Examples:**

Input:arr[] = {-2, 10, 3, -8, -4, -1, 5, -2, -3, 1}Output:11Explanation:

Since the subsequence needs to be longest possible as well as alternating, one element can be selected from each of the following subarrays:

{-2}, {10, 3}, {-8, -4, -1}, {5}, {-2, -3}, {1}

Hence, selecting the maximum from each of the subarrays as the elements of the subsequence generates an alternating subsequence with maximum sum.

Therefore, the subsequence is {-2, 10, -1, 5, -2, 1}

Hence, the sum of the subsequence is 11.Input:arr[] = {12, 4, -5, 7, -9}Output:5Explanation:

The longest subsequence with greatest sum is {12, -5, 7, -9}.

Hence, the maximum sum is 5.

**Linear Approach using extra-space:**

Refer to Longest alternating subsequence which has maximum sum of elements for the linear approach using extra space. **Time Complexity:** O(N) **Auxiliary Space:** O(N)**Space-Efficient Approach:**

To solve the problem, we can observe the following:

- To maximize the length of the alternating subsequence, we need to consider an element from every sequence of consecutive numbers of the

Illustration:

Let us consider an array arr[] = {1, 1, 2, -1, -5, 2, 1, -3}

The consecutive sequences of elements of same sign are:

{1, 1, 2}, {-1, -5}, {2, 1}, {-3}

Hence, by selecting an element from each of these sequences, an alternating subsequence of the longest possible length can be obtained.

- To maximize the sum of the subsequence, we need to select the maximum from each consecutive subsequence of elements of the same sign.

Illustration:

For the array arr[] = {1, 1, 2, -1, -5, 2, 1, -3}, the consecutive sequences of elements of sign were observed to be:

{1, 1, 2}, {-1, -5}, {2, 1}, {-3}

Therefore, the subsequence with the maximum sum is {2, -1, 2, -3}, formed by selecting the maximum element from each of the sequences.

Follow the steps below to solve the problem efficiently:

- Iterate over the array using Two Pointers.
- Set
**i = 0**, and set**j = i**. - Traverse the array until
**j**points to an index consisting of an element of*sign opposite to that of arr[i]*. At every traversal, update the maximum element encountered between**[i, j]**. - Once an element of opposite sign is found, add the maximum from the sequence
**[i, j)**to**maxsum**. - Set
**i = j**, and repeat the above two steps until the entire array is traversed. - Print the final value of
**maxsum**as the answer.

Below is the implementation of the above approach:

## C++

`// C++ Program to implement` `// the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to check the` `// sign of the element` `int` `sign(` `int` `x)` `{` ` ` `if` `(x > 0)` ` ` `return` `1;` ` ` `else` ` ` `return` `-1;` `}` `// Function to calculate and` `// return the maximum sum of` `// longest alternating subsequence` `int` `findMaxSum(` `int` `arr[], ` `int` `size)` `{` ` ` `int` `max_sum = 0, pres, i, j;` ` ` `// Iterate through the array` ` ` `for` `(i = 0; i < size; i++) {` ` ` `// Stores the first element of` ` ` `// a sequence of same sign` ` ` `pres = arr[i];` ` ` `j = i;` ` ` `// Traverse until an element with` ` ` `// opposite sign is encountered` ` ` `while` `(j < size` ` ` `&& sign(arr[i])` ` ` `== sign(arr[j])) {` ` ` `// Update the maximum` ` ` `pres = max(pres, arr[j]);` ` ` `j++;` ` ` `}` ` ` `// Update the maximum sum` ` ` `max_sum = max_sum + pres;` ` ` `// Update i` ` ` `i = j - 1;` ` ` `}` ` ` `// Return the maximum sum` ` ` `return` `max_sum;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `arr[] = { -2, 8, 3, 8, -4,` ` ` `-15, 5, -2, -3, 1 };` ` ` `int` `size = ` `sizeof` `(arr) ` `/ ` `sizeof` `(arr[0]);` ` ` `cout << findMaxSum(arr, size);` ` ` `return` `0;` `}` |

*chevron_right*

*filter_none*

## Java

`// Java Program to implement` `// the above approach` `import` `java.util.*;` `class` `GFG{` ` ` `// Function to check the` ` ` `// sign of the element` ` ` `static` `int` `sign(` `int` `x)` ` ` `{` ` ` `if` `(x > ` `0` `)` ` ` `return` `1` `;` ` ` `else` ` ` `return` `-` `1` `;` ` ` `}` ` ` `// Function to calculate and` ` ` `// return the maximum sum of` ` ` `// longest alternating subsequence` ` ` `static` `int` `findMaxSum(` `int` `arr[], ` `int` `size)` ` ` `{` ` ` `int` `max_sum = ` `0` `, pres, i, j;` ` ` `// Iterate through the array` ` ` `for` `(i = ` `0` `; i < size; i++)` ` ` `{` ` ` `// Stores the first element of` ` ` `// a sequence of same sign` ` ` `pres = arr[i];` ` ` `j = i;` ` ` `// Traverse until an element with` ` ` `// opposite sign is encountered` ` ` `while` `(j < size && ` ` ` `sign(arr[i]) == sign(arr[j]))` ` ` `{` ` ` `// Update the maximum` ` ` `pres = Math.max(pres, arr[j]);` ` ` `j++;` ` ` `}` ` ` `// Update the maximum sum` ` ` `max_sum = max_sum + pres;` ` ` `// Update i` ` ` `i = j - ` `1` `;` ` ` `}` ` ` `// Return the maximum sum` ` ` `return` `max_sum;` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `int` `arr[] = { -` `2` `, ` `8` `, ` `3` `, ` `8` `, -` `4` `, -` `15` `, ` `5` `, -` `2` `, -` `3` `, ` `1` `};` ` ` `int` `size = arr.length;` ` ` `System.out.println(findMaxSum(arr, size));` ` ` `}` `}` `// This code is contributed by sapnasingh4991` |

*chevron_right*

*filter_none*

## Python

`# Python3 program to implement` `# the above approach` `# Function to check the` `# sign of the element` `def` `sign(x):` ` ` `if` `(x > ` `0` `):` ` ` `return` `1` ` ` `else` `:` ` ` `return` `-` `1` `# Function to calculate and` `# return the maximum sum of` `# longest alternating subsequence` `def` `findMaxSum(arr, size):` ` ` ` ` `max_sum ` `=` `0` ` ` `# Iterate through the array` ` ` `i ` `=` `0` ` ` `while` `i < size:` ` ` `# Stores the first element of` ` ` `# a sequence of same sign` ` ` `pres ` `=` `arr[i]` ` ` `j ` `=` `i` ` ` `# Traverse until an element with` ` ` `# opposite sign is encountered` ` ` `while` `(j < size ` `and` ` ` `(sign(arr[i]) ` `=` `=` `sign(arr[j]))):` ` ` `# Update the maximum` ` ` `pres ` `=` `max` `(pres, arr[j])` ` ` `j ` `+` `=` `1` ` ` `# Update the maximum sum` ` ` `max_sum ` `=` `max_sum ` `+` `pres` ` ` `# Update i` ` ` `i ` `=` `j ` `-` `1` ` ` `i ` `+` `=` `1` ` ` `# Return the maximum sum` ` ` `return` `max_sum` `# Driver Code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` ` ` `arr ` `=` `[ ` `-` `2` `, ` `8` `, ` `3` `, ` `8` `, ` `-` `4` `,` ` ` `-` `15` `, ` `5` `, ` `-` `2` `, ` `-` `3` `, ` `1` `]` ` ` `size ` `=` `len` `(arr)` ` ` `print` `(findMaxSum(arr, size))` `# This code is contributed by chitranayal` |

*chevron_right*

*filter_none*

## C#

`// C# Program to implement` `// the above approach` `using` `System;` `class` `GFG{` ` ` `// Function to check the` ` ` `// sign of the element` ` ` `static` `int` `sign(` `int` `x)` ` ` `{` ` ` `if` `(x > 0)` ` ` `return` `1;` ` ` `else` ` ` `return` `-1;` ` ` `}` ` ` `// Function to calculate and` ` ` `// return the maximum sum of` ` ` `// longest alternating subsequence` ` ` `static` `int` `findMaxSum(` `int` `[]arr, ` `int` `size)` ` ` `{` ` ` `int` `max_sum = 0, pres, i, j;` ` ` `// Iterate through the array` ` ` `for` `(i = 0; i < size; i++)` ` ` `{` ` ` `// Stores the first element of` ` ` `// a sequence of same sign` ` ` `pres = arr[i];` ` ` `j = i;` ` ` `// Traverse until an element with` ` ` `// opposite sign is encountered` ` ` `while` `(j < size && ` ` ` `sign(arr[i]) == sign(arr[j]))` ` ` `{` ` ` `// Update the maximum` ` ` `pres = Math.Max(pres, arr[j]);` ` ` `j++;` ` ` `}` ` ` `// Update the maximum sum` ` ` `max_sum = max_sum + pres;` ` ` `// Update i` ` ` `i = j - 1;` ` ` `}` ` ` `// Return the maximum sum` ` ` `return` `max_sum;` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `Main(String[] args)` ` ` `{` ` ` `int` `[]arr = { -2, 8, 3, 8, -4,` ` ` `-15, 5, -2, -3, 1 };` ` ` `int` `size = arr.Length;` ` ` `Console.WriteLine(findMaxSum(arr, size));` ` ` `}` `}` `// This code is contributed by gauravrajput1` |

*chevron_right*

*filter_none*

**Output:**

6

**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.

## Recommended Posts:

- Longest alternating subsequence which has maximum sum of elements
- Maximum length Subsequence with alternating sign and maximum Sum
- Longest alternating subsequence in terms of positive and negative integers
- Longest Increasing Subsequence using Longest Common Subsequence Algorithm
- Length of largest subsequence consisting of a pair of alternating digits
- Longest subsequence such that every element in the subsequence is formed by multiplying previous element with a prime
- Longest alternating sub-array starting from every index in a Binary Array
- Longest alternating (positive and negative) subarray starting at every index
- Length of the longest alternating subarray
- Length of the longest alternating even odd subarray
- Maximum length subsequence such that adjacent elements in the subsequence have a common factor
- Rearrange a given list such that it consists of alternating minimum maximum elements
- Sum of alternating sign Squares of first N natural numbers
- Sum of alternating sign cubes of first N Natural numbers
- Rearrange array in alternating positive & negative items with O(1) extra space | Set 1
- Rearrange array in alternating positive & negative items with O(1) extra space | Set 2
- Minimum number of replacements to make the binary string alternating | Set 2
- Longest subsequence whose sum is divisible by a given number
- Maximize sum of all elements which are not a part of the Longest Increasing Subsequence
- Longest Increasing Subsequence having sum value atmost K

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.