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 0Input: 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 * 2N)
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 sumvoid 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 Codeint 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 sumstatic 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 Codepublic 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 sumdef 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 codearr = [ 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 sumstatic 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 Codepublic 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 sumfunction 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 codelet 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 approachimport sysfrom typing import List, Tupledef 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 approachfunction 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 functionfunction 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 functionmain(); |
Output
6 1 2 3 0
Time Complexity: O(2^N) +O(N*N)
Auxiliary Space: O(N*N)
Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
