Longest alternating subsequence which has maximum sum of elements
Last Updated :
19 Dec, 2022
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 of 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
Explanation:
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: 5
Explanation:
The largest subsequence with greatest sum is [12 -5 7 -9] with length 4.
Approach: The solution can be reached by the following approach:-
- To get alternating subsequences with maximum length and the 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 element of the 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 elements of opposite sign, we will simply add those elements to that list named large.
- Finally, the list named large will have the longest alternating subsequence with the 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].
- 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=[3]
- Now -2 and -5 have the same sign so we will append -2 to another List.
large=[3, -2]
- Now, the sign of 1 and -7 are opposite, so we will append 1 to large.
large=[3, -2, 1]
- For -7, -1 signs are same, Hence append -1 to large.
large=[3, -2, 1, -1]
- Calculate the sum = 3 – 2 + 1 – 1 = 1
Below is the implementation of the above approach:
C++
#include<bits/stdc++.h>
using namespace std;
int calculateMaxSum( int n, int li[])
{
vector< int > ar;
ar.push_back(li[0]);
vector< int > large;
for ( int j = 0; j < n - 1; j++)
{
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)
{
large.push_back(*max_element(ar.begin(),
ar.end()));
ar.clear();
ar.push_back(li[j + 1]);
}
else if (li[j] < 0 and li[j + 1] > 0)
{
large.push_back(*max_element(ar.begin(),
ar.end()));
ar.clear();
ar.push_back(li[j + 1]);
}
else
{
ar.push_back(li[j + 1]);
}
}
large.push_back(*max_element(ar.begin(),
ar.end()));
int sum = 0;
for ( int i = 0; i < large.size(); i++)
sum += large[i];
return sum;
}
int main()
{
int list[] = { -2, 8, 3, 8, -4, -15,
5, -2, -3, 1 };
int N = sizeof (list) / sizeof (list[0]);
cout << (calculateMaxSum(N, list));
}
|
Java
import java.util.*;
class GFG{
static int calculateMaxSum( int n, int li[])
{
Vector<Integer> ar = new Vector<>();
ar.add(li[ 0 ]);
Vector<Integer> large = new Vector<>();
for ( int j = 0 ; j < n - 1 ; j++)
{
if (li[j] > 0 && li[j + 1 ] > 0 )
{
ar.add(li[j + 1 ]);
}
else if (li[j] > 0 && li[j + 1 ] < 0 )
{
large.add(Collections.max(ar));
ar.clear();
ar.add(li[j + 1 ]);
}
else if (li[j] < 0 && li[j + 1 ] > 0 )
{
large.add(Collections.max(ar));
ar.clear();
ar.add(li[j + 1 ]);
}
else
{
ar.add(li[j + 1 ]);
}
}
large.add(Collections.max(ar));
int sum = 0 ;
for ( int i = 0 ; i < large.size(); i++)
sum += ( int )large.get(i);
return sum;
}
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));
}
}
|
Python3
def calculateMaxSum(n, li):
ar = []
ar.append(li[ 0 ])
large = []
for j in range ( 0 , n - 1 ):
if (li[j]> 0 and li[j + 1 ]> 0 ):
ar.append(li[j + 1 ])
elif (li[j]> 0 and li[j + 1 ]< 0 ):
large.append( max (ar))
ar = []
ar.append(li[j + 1 ])
elif (li[j]< 0 and li[j + 1 ]> 0 ):
large.append( max (ar))
ar = []
ar.append(li[j + 1 ])
else :
ar.append(li[j + 1 ])
large.append( max (ar))
return sum (large)
list = [ - 2 , 8 , 3 , 8 , - 4 , - 15 , 5 , - 2 , - 3 , 1 ]
N = len ( list )
print (calculateMaxSum(N, list ))
|
C#
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)
{
List< int > ar = new List< int >();
ar.Add(li[0]);
List< int > large = new List< int >();
for ( int j = 0; j < n - 1; j++)
{
if (li[j] > 0 && li[j + 1] > 0)
{
ar.Add(li[j + 1]);
}
else if (li[j] > 0 && li[j + 1] < 0)
{
large.Add(find_max(ar));
ar.Clear();
ar.Add(li[j + 1]);
}
else if (li[j] < 0 && li[j + 1] > 0)
{
large.Add(find_max(ar));
ar.Clear();
ar.Add(li[j + 1]);
}
else
{
ar.Add(li[j + 1]);
}
}
large.Add(find_max(ar));
int sum = 0;
foreach ( var i in large)
{
sum += i;
}
return sum;
}
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));
}
}
|
Javascript
<script>
function find_max(ar)
{
let mx = -1000000;
for (let i = 0; i < ar.length; i++)
{
if (ar[i] > mx)
mx = ar[i];
}
return mx;
}
function calculateMaxSum(n, li)
{
let ar = [];
ar.push(li[0]);
let large = [];
for (let j = 0; j < n - 1; j++)
{
if (li[j] > 0 && li[j + 1] > 0)
{
ar.push(li[j + 1]);
}
else if (li[j] > 0 && li[j + 1] < 0)
{
large.push(find_max(ar));
ar = [];
ar.push(li[j + 1]);
}
else if (li[j] < 0 && li[j + 1] > 0)
{
large.push(find_max(ar));
ar = [];
ar.push(li[j + 1]);
}
else
{
ar.push(li[j + 1]);
}
}
large.push(find_max(ar));
let sum = 0;
for (let i = 0; i < large.length; i++)
{
sum += large[i];
}
return sum;
}
let list = [ -2, 8, 3, 8, -4, -15, 5, -2, -3, 1 ];
let N = (list.length);
document.write(calculateMaxSum(N, list));
</script>
|
Time Complexity:O(N2)
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...