Longest subsequence having maximum sum

Given an array arr[] of size N, the task is to find the longest non-empty subsequence from the given array whose sum is maximum.

Examples:

Input: arr[] = { 1, 2, -4, -2, 3, 0 } 
Output: 1 2 3 0 
Explanation:
Sum of elements of the subsequence {1, 2, 3, 0} is 6 which is the maximum possible sum. 
Therefore, the required output is 1 2 3 0

Input: arr[] = { -10, -6, -2, -3, -4 } 
Output: -2

Naive Approach: The simplest approach to solve this problem is to traverse the array and generate all possible subsequence of the given array and calculate their sums. Print the longest of all subsequences with maximum sum. 

Time Complexity: O(N * 2^N)
Auxiliary Space: O(N)

Efficient Approach: The problem can be solved using Greedy technique. Follow the steps below to solve the problem:

• Initialize a variable, say maxm, to store the largest element of the given array.
• If maxm < 0, then print the value of maxm.
• Otherwise, traverse the array and print all positive array elements.

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 find the longest subsequence
// from the given array with maximum sum
void longestSubWithMaxSum(int arr[], int N)
{
    // Stores the largest element
    // of the array
    int Max = *max_element(arr,
                           arr + N);

    // If Max is less than 0
    if (Max < 0) {

        // Print the largest element
        // of the array
        cout << Max;
        return;
    }

    // Traverse the array
    for (int i = 0; i < N; i++) {

        // If arr[i] is greater
        // than or equal to 0
        if (arr[i] >= 0) {

            // Print elements of
            // the subsequence
            cout << arr[i] << " ";
        }
    }
}

// Driver Code
int main()
{
    int arr[] = { 1, 2, -4, -2, 3, 0 };

    int N = sizeof(arr) / sizeof(arr[0]);

    longestSubWithMaxSum(arr, N);
    return 0;
}

Java

// Java program to implement
// the above approach
import java.util.*;

class GFG{

// Function to find the longest subsequence
// from the given array with maximum sum
static void longestSubWithMaxSum(int arr[], int N)
{

    // Stores the largest element
    // of the array
    int Max = Arrays.stream(arr).max().getAsInt();

    // If Max is less than 0
    if (Max < 0)
    {

        // Print the largest element
        // of the array
        System.out.print(Max);
        return;
    }

    // Traverse the array
    for(int i = 0; i < N; i++)
    {

        // If arr[i] is greater
        // than or equal to 0
        if (arr[i] >= 0)
        {

            // Print elements of
            // the subsequence
            System.out.print(arr[i] + " ");
        }
    }
}

// Driver Code
public static void main(String[] args)
{
    int arr[] = { 1, 2, -4, -2, 3, 0 };
    int N = arr.length;

    longestSubWithMaxSum(arr, N);
}
}

// This code is contributed by code_hunt

Python3

# Python3 program to implement
# the above approach

# Function to find the longest subsequence
# from the given array with maximum sum
def longestSubWithMaxSum(arr, N):

    # Stores the largest element
    # of the array
    Max = max(arr)

    # If Max is less than 0
    if (Max < 0) :

        # Print the largest element
        # of the array
        print(Max)
        return

    # Traverse the array
    for i in range(N):

        # If arr[i] is greater
        # than or equal to 0
        if (arr[i] >= 0) :

            # Print elements of
            # the subsequence
            print(arr[i], end = " ")

# Driver code
arr = [ 1, 2, -4, -2, 3, 0 ]

N = len(arr)

longestSubWithMaxSum(arr, N)

# This code is contributed divyeshrabadiya07

C#

// C# program to implement
// the above approach
using System;

class GFG{

// Function to find the longest subsequence
// from the given array with maximum sum
static void longestSubWithMaxSum(int []arr,
                                 int N)
{

    // Stores the largest element
    // of the array
    int Max = arr[0];

    for(int i = 1; i < N; i++)
    {
        if (Max < arr[i])
            Max = arr[i];
    }

    // If Max is less than 0
    if (Max < 0)
    {

        // Print the largest element
        // of the array
        Console.Write(Max);
        return;
    }

    // Traverse the array
    for(int i = 0; i < N; i++)
    {

        // If arr[i] is greater
        // than or equal to 0
        if (arr[i] >= 0)
        {

            // Print elements of
            // the subsequence
            Console.Write(arr[i] + " ");
        }
    }
}

// Driver Code
public static void Main(String[] args)
{
    int []arr = { 1, 2, -4, -2, 3, 0 };
    int N = arr.Length;

    longestSubWithMaxSum(arr, N);
}
}

// This code is contributed by aashish1995

Javascript

<script>

// JavaScript program to implement
// the above approach

// Function to find the longest subsequence
// from the given array with maximum sum
function longestSubWithMaxSum(arr, N)
{

    // Stores the largest element
    // of the array
    let Max = Math.max(...arr);

    // If Max is less than 0
    if (Max < 0)
    {

        // Print the largest element
        // of the array
        document.write(Max);
        return;
    }

    // Traverse the array
    for(let i = 0; i < N; i++)
    {

        // If arr[i] is greater
        // than or equal to 0
        if (arr[i] >= 0)
        {

            // Print the elements of
            // the subsequence
            document.write(arr[i] + " ");
        }
    }
}

// Driver code
let arr = [ 1, 2, -4, -2, 3, 0 ];
let N = arr.length;

longestSubWithMaxSum(arr, N);

// This code is contributed by avijitmondal1998

</script>

Output:

1 2 3 0

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

The AllPossible Subsequence Generator And Checking Way :

C++

#include<bits/stdc++.h>
#include<iostream>
using namespace std;

void the_allpossible_getter(vector<vector<int>>&allsub,vector<int>&v,vector<int>&res,
  int n,int index){
  if(index>=n){
    allsub.push_back(res);
    return;
  }
  res.push_back(v[index]);
  index+=1;
  the_allpossible_getter(allsub,v,res,n,index);
  index+=1;
  res.pop_back();
  the_allpossible_getter(allsub,v,res,n,index);
}
signed main(){
  vector<int>v{ 1, 2, -4, -2, 3, 0 };
  int n=6;
  vector<int>res;
  vector<vector<int>>allsub;
  the_allpossible_getter(allsub,v,res,n,0);
  res.clear();
  int maxsum=INT_MIN;
  for(auto it:allsub){
    int sum=0;
    vector<int>dump;
    for(auto vt:it){
       sum+=vt;
       dump.push_back(vt);
    }
    if(sum>maxsum){
     maxsum=max(maxsum,sum);
     res.clear();
     res=dump;
   }
  }
  cout<<maxsum<<endl;
  for(auto it:res)cout<<it<<" ";
    return 0;
}

Java

import java.util.*;

class Main {
  public static void the_allpossible_getter(List<List<Integer>> allsub, List<Integer> v, List<Integer> res, int n, int index) {
    if (index >= n) {
      allsub.add(new ArrayList<>(res));
      return;
    }
    res.add(v.get(index));
    the_allpossible_getter(allsub, v, res, n, index + 1);
    res.remove(res.size() - 1);
    the_allpossible_getter(allsub, v, res, n, index + 1);
  }

  public static void main(String[] args) {
    List<Integer> v = Arrays.asList(1, 2, -4, -2, 3, 0);
    int n = v.size();
    List<Integer> res = new ArrayList<>();
    List<List<Integer>> allsub = new ArrayList<>();
    the_allpossible_getter(allsub, v, res, n, 0);
    int maxsum = Integer.MIN_VALUE;
    List<Integer> maxsub = new ArrayList<>();
    for (List<Integer> it : allsub) {
      int sum = 0;
      for (Integer vt : it) {
        sum += vt;
      }
      if (sum > maxsum) {
        maxsum = sum;
        maxsub = it;
      }
    }
    System.out.println(maxsum);
    for (Integer it : maxsub) {
      System.out.print(it + " ");
    }
  }
}

// This code is contributed by aadityaburujwale.

Python3

# Python program for above approach
import sys
from typing import List, Tuple

def the_allpossible_getter(allsub: List[List[int]], v: List[int], res: List[int], n: int, index: int):
    if index >= n:
        allsub.append(res[:])
        return

    res.append(v[index])
    index+=1
    the_allpossible_getter(allsub, v, res, n, index)
    index+=1
    res.pop()
    the_allpossible_getter(allsub, v, res, n, index)

if __name__ == "__main__":
    v = [1, 2, -4, -2, 3, 0]
    n = 6
    res = []
    allsub = []
    the_allpossible_getter(allsub, v, res, n, 0)
    maxsum = -sys.maxsize
    maxsub = []
    for sub in allsub:
        s = sum(sub)
        if s > maxsum:
            maxsum = s
            maxsub = sub
    print(maxsum)
    print(*maxsub)


# This code is contributed by Aman Kumar.

C#

using System;
using System.Collections.Generic;
using System.Linq;

class GFG {
    public static void the_allpossible_getter(List<List<int>> allsub, List<int> v, List<int> res, int n, int index) {
        if (index >= n) {
            allsub.Add(new List<int>(res));
            return;
        }
        res.Add(v[index]);
        the_allpossible_getter(allsub, v, res, n, index + 1);
        res.RemoveAt(res.Count - 1);
        the_allpossible_getter(allsub, v, res, n, index + 1);
    }
    public static void Main(string[] args) {
        List<int> v = new List<int>{1, 2, -4, -2, 3, 0};
        int n = v.Count;
        List<int> res = new List<int>();
        List<List<int>> allsub = new List<List<int>>();
        the_allpossible_getter(allsub, v, res, n, 0);
        int maxsum = int.MinValue;
        List<int> maxsub = new List<int>();
        foreach (List<int> it in allsub) {
            int sum = 0;
            foreach (int vt in it) {
                sum += vt;
            }
            if (sum > maxsum) {
                maxsum = sum;
                maxsub = it;
            }
        }
        Console.WriteLine(maxsum);
        foreach (int it in maxsub) {
            Console.Write(it + " ");
        }
    }
}

Javascript

// JavaScript program for above approach
function the_allpossible_getter(allsub, v, res, n, index) {

  // Recursive function to get all possible subsets of v
  if (index >= n) {

    // If index is equal to or greater than n,
    // append current subset to allsub and return
    allsub.push(res.slice());
    return;
  }

  res.push(v[index]);
  index += 1;
  the_allpossible_getter(allsub, v, res, n, index);
  index += 1;
  res.pop();
  the_allpossible_getter(allsub, v, res, n, index);
}

// Main function
function main() {
  const v = [1, 2, -4, -2, 3, 0];
  const n = 6;
  let res = [];
  let allsub = [];
  the_allpossible_getter(allsub, v, res, n, 0);
  let maxsum = Number.MIN_SAFE_INTEGER;
  let maxsub = [];
  for (let sub of allsub) {

    // Iterate over all subsets to
    // find the subset with maximum sum
    let s = sub.reduce((a, b) => a + b, 0);
    if (s > maxsum) {
      maxsum = s;
      maxsub = sub;
    }
  }
  console.log(maxsum);
  console.log(...maxsub);
}

// Call the main function
main();

Output

6
1 2 3 0 

Time Complexity: O(2^N) +O(N*N)
Auxiliary Space: O(N*N)