Skip to content
Related Articles

Related Articles

Maximum length Subsequence with alternating sign and maximum Sum
  • Last Updated : 05 May, 2020

Given an array arr[] of size n having both positive and negative integer excluding zero. The task is to find the subsequence with an alternating sign having maximum size and maximum sum that is, in a subsequence sign of each adjacent element is opposite for example if the first one is positive then the second one has to be negative followed by another positive integer and so on.

Examples:

Input: arr[] = {2, 3, 7, -6, -4}
Output: 7 -4
Explanation:
Possible subsequences are [2, -6] [2, -4] [3, -6] [3, -4] [7, -6] [7, -4].
Out of these [7, -4] has the maximum sum. 

Input: arr[] = {-4, 9, 4, 11, -5, -17, 9, -3, -5, 2}
Output: -4 11 -5 9 -3 2  

Approach:

The main idea to solve the above problem is to find the maximum element from the segments of the array which consists of the same sign which means we have to pick the maximum element among continuous positive and continuous negative elements. As we want maximum size we will only take one element from each segment and also to maximize the sum, we need to take the maximum element of each segment.

Below is the implementation of the above approach:

CPP



filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation to find the
// subsequence with alternating sign
// having maximum size and maximum sum.
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to find the subsequence
// with alternating sign having
// maximum size and maximum sum.
void findSubsequence(int arr[], int n)
{
    int sign[n] = { 0 };
  
    // Find whether each element
    // is positive or negative
    for (int i = 0; i < n; i++) {
        if (arr[i] > 0)
            sign[i] = 1;
        else
            sign[i] = -1;
    }
  
    int k = 0;
    int result[n] = { 0 };
  
    // Find the required subsequence
    for (int i = 0; i < n; i++) {
  
        int cur = arr[i];
        int j = i;
  
        while (j < n && sign[i] == sign[j]) {
  
            // Find the maximum element
            // in the specified range
            cur = max(cur, arr[j]);
            ++j;
        }
  
        result[k++] = cur;
  
        i = j - 1;
    }
  
    // print the result
    for (int i = 0; i < k; i++)
        cout << result[i] << " ";
    cout << "\n";
}
  
// Driver code
int main()
{
    // array declaration
    int arr[] = { -4, 9, 4, 11, -5, -17, 9, -3, -5, 2 };
  
    // size of array
    int n = sizeof(arr) / sizeof(arr[0]);
  
    findSubsequence(arr, n);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation to find the
// subsequence with alternating sign
// having maximum size and maximum sum.
class GFG{
   
// Function to find the subsequence
// with alternating sign having
// maximum size and maximum sum.
static void findSubsequence(int arr[], int n)
{
    int sign[] = new int[n];
   
    // Find whether each element
    // is positive or negative
    for (int i = 0; i < n; i++) {
        if (arr[i] > 0)
            sign[i] = 1;
        else
            sign[i] = -1;
    }
   
    int k = 0;
    int result[] = new int[n];
   
    // Find the required subsequence
    for (int i = 0; i < n; i++) {
   
        int cur = arr[i];
        int j = i;
   
        while (j < n && sign[i] == sign[j]) {
   
            // Find the maximum element
            // in the specified range
            cur = Math.max(cur, arr[j]);
            ++j;
        }
   
        result[k++] = cur;
   
        i = j - 1;
    }
   
    // print the result
    for (int i = 0; i < k; i++)
        System.out.print(result[i]+ " ");
    System.out.print("\n");
}
   
// Driver code
public static void main(String[] args)
{
    // array declaration
    int arr[] = { -4, 9, 4, 11, -5, -17, 9, -3, -5, 2 };
   
    // size of array
    int n = arr.length;
   
    findSubsequence(arr, n);
}
}
  
// This code is contributed by Princi Singh

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation to find the
# subsequence with alternating sign
# having maximum size and maximum sum.
  
# Function to find the subsequence
# with alternating sign having
# maximum size and maximum sum.
def findSubsequence(arr, n):
    sign = [0]*n
  
    # Find whether each element
    # is positive or negative
    for i in range(n):
        if (arr[i] > 0):
            sign[i] = 1
        else:
            sign[i] = -1
  
    k = 0
    result = [0]*n
  
    # Find the required subsequence
    i = 0
    while i < n:
  
        cur = arr[i]
        j = i
  
        while (j < n and sign[i] == sign[j]):
  
            # Find the maximum element
            # in the specified range
            cur = max(cur, arr[j])
            j += 1
  
        result[k] = cur
        k += 1
  
        i = j - 1
        i += 1
  
    # print the result
    for i in range(k):
        print(result[i],end=" ")
  
# Driver code
if __name__ == '__main__':
    # array declaration
    arr=[-4, 9, 4, 11, -5, -17, 9, -3, -5, 2]
  
    # size of array
    n = len(arr)
  
    findSubsequence(arr, n)
  
# This code is contributed by mohit kumar 29

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation to find the
// subsequence with alternating sign
// having maximum size and maximum sum.
using System;
  
public class GFG{
    
// Function to find the subsequence
// with alternating sign having
// maximum size and maximum sum.
static void findSubsequence(int []arr, int n)
{
    int []sign = new int[n];
    
    // Find whether each element
    // is positive or negative
    for (int i = 0; i < n; i++) {
        if (arr[i] > 0)
            sign[i] = 1;
        else
            sign[i] = -1;
    }
    
    int k = 0;
    int []result = new int[n];
    
    // Find the required subsequence
    for (int i = 0; i < n; i++) {
    
        int cur = arr[i];
        int j = i;
    
        while (j < n && sign[i] == sign[j]) {
    
            // Find the maximum element
            // in the specified range
            cur = Math.Max(cur, arr[j]);
            ++j;
        }
    
        result[k++] = cur;
    
        i = j - 1;
    }
    
    // print the result
    for (int i = 0; i < k; i++)
        Console.Write(result[i]+ " ");
    Console.Write("\n");
}
    
// Driver code
public static void Main(String[] args)
{
    // array declaration
    int []arr = { -4, 9, 4, 11, -5, -17, 9, -3, -5, 2 };
    
    // size of array
    int n = arr.Length;
    
    findSubsequence(arr, n);
}
}
// This code contributed by Rajput-Ji

chevron_right


Output:

-4 11 -5 9 -3 2

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
Recommended Articles
Page :