# Longest alternating subsequence which has maximum sum of elements

Given a list of length N with positive and negative integers. The task is to choose the longest alternating subsequence of the given sequence (i.e. the sign of each next element is the opposite from the sign of the current element). Among all such subsequences, we have to choose one which has the maximum sum of elements and display that sum.
Examples:

Input: list = [-2 10 3 -8 -4 -1 5 -2 -3 1]
Output: 11
Explaination:
The largest subsequence with the greatest sum is [-2 10 -1 5 -2 1] with length 6.

Input: list=[12 4 -5 7 -9]
Output:
Explaination:
The largest subsequence with greatest sum is [12 -5 7 -9] with length 4.

Approach: The solution can be reached by following approach:-

• For getting alternating subsequence with maximum length and largest sum we will be traversing the whole list (length of list)-1 times for comparing signs of consecutive elements.
• During traversal if we are getting more than 1 consecutive elements of same sign(exp. 1 2 4), then we will append the maximum element out of them to another list named large. so from 1 2 and 4 we will append 4 to another list.
• If we have consecutive element of opposite sign we will simply add those elements to that list named large.
• Finally the list named large will have longest alternating subsequence with largest elements.
• Now, we will have to calculate the sum of all elements from that list named large.

Lets take an example, we have a list [1, 2, 3, -2, -5, 1, -7, -1].

1. In traversing this list length-1 times, we are getting 1, 2, 3 with the same sign so we will append greatest of these (i.e 3) to another list named large here.
Hence large=
2. Now -2 and -5 have the same sign so we will append -2 to another List.
large=[3, -2]
3. Now, the sign of 1 and -7 are opposite, so we will append 1 to large.
large=[3, -2, 1]
4. For -7, -1 signs are same, Hence append -1 to large.
large=[3, -2, 1, -1]
5. Calculate the sum = 3 – 2 + 1 – 1 = 1

Below is the implementation of the above approach:

## C++

 `// C++ implementation to find the  ` `// longest alternating subsequence  ` `// which has the maximum sum ` `#include ` `using` `namespace` `std; ` ` `  `int` `calculateMaxSum(``int` `n, ``int` `li[]) ` `{ ` `     `  `    ``// Creating a temporary list ar to  ` `    ``// every time store same sign element ` `    ``// to calculate maximum element from  ` `    ``// that list ar ` `    ``vector<``int``> ar; ` `     `  `    ``// Appending 1st element of list li  ` `    ``// to the ar ` `    ``ar.push_back(li); ` `     `  `    ``// Creating list to store maximum  ` `    ``// values  ` `    ``vector<``int``> large; ` ` `  `    ``for``(``int` `j = 0; j < n - 1; j++) ` `    ``{ ` `        `  `       ``// If both number are positive  ` `       ``// then append (j + 1)th element  ` `       ``// to temporary list ar ` `       ``if``(li[j] > 0 and li[j + 1] > 0) ` `       ``{ ` `           ``ar.push_back(li[j + 1]); ` `       ``} ` `       ``else` `if``(li[j] > 0 and li[j + 1] < 0) ` `       ``{ ` `            `  `           ``// If opposite elements found  ` `           ``// then append maximum element  ` `           ``// to large list ` `           ``large.push_back(*max_element(ar.begin(),  ` `                                        ``ar.end())); ` `                                         `  `           ``// Empty ar list to re-append ` `           ``// next elements  ` `           ``ar.clear(); ` `           ``ar.push_back(li[j + 1]); ` `       ``} ` `       ``else` `if``(li[j] < 0 and li[j + 1] > 0) ` `       ``{ ` `            `  `           ``// If opposite elements found  ` `           ``// then append maximum element ` `           ``// to large list ` `           ``large.push_back(*max_element(ar.begin(), ` `                                        ``ar.end())); ` `            `  `           ``// Empty ar list to re-append  ` `           ``// next elements  ` `           ``ar.clear(); ` `           ``ar.push_back(li[j + 1]); ` `       ``} ` `       ``else` `       ``{ ` `           ``// If both number are negative ` `           ``// then append (j + 1)th element ` `           ``// to temporary list ar  ` `           ``ar.push_back(li[j + 1]); ` `       ``} ` `    ``} ` `     `  `    ``// The final Maximum element in ar list ` `    ``// also needs to be appended to large list  ` `    ``large.push_back(*max_element(ar.begin(), ` `                                 ``ar.end())); ` `     `  `    ``// Returning the sum of all elements  ` `    ``// from largest elements list with ` `    ``// largest alternating subsequence size ` `    ``int` `sum = 0; ` `    ``for``(``int` `i = 0; i < large.size(); i++) ` `       ``sum += large[i]; ` `    ``return` `sum; ` `} ` `     `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `list[] = { -2, 8, 3, 8, -4, -15, ` `                    ``5, -2, -3, 1 }; ` `    ``int` `N = ``sizeof``(list) / ``sizeof``(list); ` ` `  `    ``cout << (calculateMaxSum(N, list)); ` `} ` ` `  `// This code is contributed by Bhupendra_Singh `

## Java

 `// Java implementation to find the  ` `// longest alternating subsequence  ` `// which has the maximum sum  ` `import` `java.util.*; ` ` `  `class` `GFG{ ` ` `  `static` `int` `calculateMaxSum(``int` `n, ``int` `li[])  ` `{  ` `     `  `    ``// Creating a temporary list ar to  ` `    ``// every time store same sign element  ` `    ``// to calculate maximum element from  ` `    ``// that list ar  ` `    ``Vector ar = ``new` `Vector<>();  ` `     `  `    ``// Appending 1st element of list li  ` `    ``// to the ar  ` `    ``ar.add(li[``0``]);  ` `     `  `    ``// Creating list to store maximum  ` `    ``// values  ` `    ``Vector large = ``new` `Vector<>(); ` ` `  `    ``for``(``int` `j = ``0``; j < n - ``1``; j++)  ` `    ``{  ` `         `  `        ``// If both number are positive  ` `        ``// then append (j + 1)th element  ` `        ``// to temporary list ar  ` `        ``if``(li[j] > ``0` `&& li[j + ``1``] > ``0``)  ` `        ``{  ` `            ``ar.add(li[j + ``1``]);  ` `        ``}  ` `        ``else` `if``(li[j] > ``0` `&& li[j + ``1``] < ``0``)  ` `        ``{  ` `                 `  `            ``// If opposite elements found  ` `            ``// then append maximum element  ` `            ``// to large list  ` `            ``large.add(Collections.max(ar));  ` `                                             `  `            ``// Empty ar list to re-append  ` `            ``// next elements  ` `            ``ar.clear();  ` `            ``ar.add(li[j + ``1``]);  ` `        ``}  ` `        ``else` `if``(li[j] < ``0` `&& li[j + ``1``] > ``0``)  ` `        ``{  ` `                 `  `            ``// If opposite elements found  ` `            ``// then append maximum element  ` `            ``// to large list  ` `            ``large.add(Collections.max(ar));  ` `                 `  `            ``// Empty ar list to re-append  ` `            ``// next elements  ` `            ``ar.clear();  ` `            ``ar.add(li[j + ``1``]);  ` `        ``}  ` `        ``else` `        ``{  ` `            ``// If both number are negative  ` `            ``// then append (j + 1)th element  ` `            ``// to temporary list ar  ` `            ``ar.add(li[j + ``1``]);  ` `        ``}  ` `    ``}  ` `     `  `    ``// The final Maximum element in ar list  ` `    ``// also needs to be appended to large list  ` `    ``large.add(Collections.max(ar));  ` `     `  `    ``// Returning the sum of all elements  ` `    ``// from largest elements list with  ` `    ``// largest alternating subsequence size  ` `    ``int` `sum = ``0``;  ` `    ``for``(``int` `i = ``0``; i < large.size(); i++)  ` `        ``sum += (``int``)large.get(i);  ` `         `  `    ``return` `sum;  ` `}  ` ` `  `// Driver code ` `public` `static` `void` `main(String args[])  ` `{  ` `    ``int` `list[] = { -``2``, ``8``, ``3``, ``8``, -``4``, -``15``,  ` `                    ``5``, -``2``, -``3``, ``1` `};  ` `    ``int` `N = (list.length); ` `     `  `    ``System.out.print(calculateMaxSum(N, list)); ` `} ` `} ` ` `  `// This code is contributed by Stream_Cipher `

## Python3

 `# Python3 implementation to find the  ` `# longest alternating subsequence  ` `# which has the maximum sum ` ` `  `def` `calculateMaxSum(n, li): ` `    ``# Creating a temporary list ar to every ` `    ``# time store same sign element to  ` `    ``# calculate maximum element from  ` `    ``# that list ar ` `    ``ar ``=``[] ` `     `  `    ``# Appending 1st element of list li  ` `    ``# to the ar ` `    ``ar.append(li[``0``]) ` `     `  `    ``# Creating list to store maximum  ` `    ``# values  ` `    ``large ``=``[] ` `     `  `    ``for` `j ``in` `range``(``0``, n``-``1``): ` `         `  `        ``# If both number are positive  ` `        ``# then append (j + 1)th element  ` `        ``# to temporary list ar ` `        ``if``(li[j]>``0` `and` `li[j ``+` `1``]>``0``): ` `            ``ar.append(li[j ``+` `1``]) ` `        ``elif``(li[j]>``0` `and` `li[j ``+` `1``]<``0``): ` `             `  `            ``# If opposite elements found  ` `            ``# then append maximum element  ` `            ``# to large list ` `            ``large.append(``max``(ar)) ` `             `  `            ``# Empty ar list to re-append ` `            ``# next elements   ` `            ``ar ``=``[] ` `            ``ar.append(li[j ``+` `1``]) ` `        ``elif``(li[j]<``0` `and` `li[j ``+` `1``]>``0``): ` `             `  `            ``# If opposite elements found  ` `            ``# then append maximum element ` `            ``# to large list ` `            ``large.append(``max``(ar)) ` `             `  `            ``# Empty ar list to re-append  ` `            ``# next elements  ` `            ``ar ``=``[] ` `            ``ar.append(li[j ``+` `1``]) ` `        ``else``: ` `            ``# If both number are negative ` `            ``# then append (j + 1)th element ` `            ``# to temporary list ar  ` `            ``ar.append(li[j ``+` `1``]) ` `             `  `    ``# The final Maximum element in ar list ` `    ``# also needs to be appended to large list  ` `    ``large.append(``max``(ar)) ` `     `  `    ``# returning the sum of all elements  ` `    ``# from largest elements list with ` `    ``# largest alternating subsequence size ` `    ``return` `sum``(large) ` ` `  ` `  `# Driver code ` `list` `=``[``-``2``, ``8``, ``3``, ``8``, ``-``4``, ``-``15``, ``5``, ``-``2``, ``-``3``, ``1``] ` `N ``=` `len``(``list``) ` ` `  `print``(calculateMaxSum(N, ``list``)) `

## C#

 `// C# implementation to find the  ` `// longest alternating subsequence  ` `// which has the maximum sum  ` `using` `System;  ` `using` `System.Collections.Generic; ` ` `  `class` `GFG{ ` ` `  `static` `int` `find_max(List<``int``> ar) ` `{ ` `    ``int` `mx = -1000000; ` `    ``foreach``(``var` `i ``in` `ar) ` `    ``{ ` `        ``if``(i > mx) ` `           ``mx = i; ` `    ``} ` `    ``return` `mx; ` `} ` ` `  `static` `int` `calculateMaxSum(``int` `n, ``int` `[]li)  ` `{  ` `     `  `    ``// Creating a temporary list ar to  ` `    ``// every time store same sign element  ` `    ``// to calculate maximum element from  ` `    ``// that list ar  ` `    ``List<``int``> ar = ``new` `List<``int``>(); ` `     `  `    ``// Appending 1st element of list li  ` `    ``// to the ar  ` `    ``ar.Add(li);  ` `     `  `    ``// Creating list to store maximum  ` `    ``// values  ` `    ``List<``int``> large = ``new` `List<``int``>(); ` ` `  `    ``for``(``int` `j = 0; j < n - 1; j++)  ` `    ``{  ` `         `  `        ``// If both number are positive  ` `        ``// then append (j + 1)th element  ` `        ``// to temporary list ar  ` `        ``if``(li[j] > 0 && li[j + 1] > 0)  ` `        ``{  ` `            ``ar.Add(li[j + 1]);  ` `        ``}  ` `        ``else` `if``(li[j] > 0 && li[j + 1] < 0)  ` `        ``{  ` `                 `  `            ``// If opposite elements found  ` `            ``// then append maximum element  ` `            ``// to large list  ` `            ``large.Add(find_max(ar));  ` `                                             `  `            ``// Empty ar list to re-append  ` `            ``// next elements  ` `            ``ar.Clear();  ` `            ``ar.Add(li[j + 1]);  ` `        ``}  ` `        ``else` `if``(li[j] < 0 && li[j + 1] > 0)  ` `        ``{  ` `                 `  `            ``// If opposite elements found  ` `            ``// then append maximum element  ` `            ``// to large list  ` `            ``large.Add(find_max(ar));  ` `                 `  `            ``// Empty ar list to re-append  ` `            ``// next elements  ` `            ``ar.Clear();  ` `            ``ar.Add(li[j + 1]);  ` `        ``}  ` `        ``else` `        ``{  ` `             `  `            ``// If both number are negative  ` `            ``// then append (j + 1)th element  ` `            ``// to temporary list ar  ` `            ``ar.Add(li[j + 1]);  ` `        ``}  ` `    ``}  ` `     `  `    ``// The final Maximum element in ar list  ` `    ``// also needs to be appended to large list  ` `    ``large.Add(find_max(ar));  ` `     `  `    ``// Returning the sum of all elements  ` `    ``// from largest elements list with  ` `    ``// largest alternating subsequence size  ` `    ``int` `sum = 0; ` `    ``foreach``(``var` `i ``in` `large) ` `    ``{ ` `        ``sum += i; ` `    ``} ` `    ``return` `sum;  ` `}  ` ` `  `// Driver code ` `public` `static` `void` `Main()  ` `{  ` `    ``int` `[]list = { -2, 8, 3, 8, -4, -15,  ` `                    ``5, -2, -3, 1 };  ` `    ``int` `N = (list.Length); ` `     `  `    ``Console.WriteLine(calculateMaxSum(N, list)); ` `} ` `} ` ` `  `// This code is contributed by Stream_Cipher     `

Output:

```6
```

Time Complexity:O(N)

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.

Improved By : bgangwar59, Stream_Cipher