# Maximum Sum Subsequence

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

Examples:

Input: arr[] = { 2, 3, 7, 1, 9 }
Output: 22
Explanation:
Sum of the subsequence { arr[0], arr[1], arr[2], arr[3], arr[4] } is equal to 22, which is the maximum possible sum of any subsequence of the array.
Therefore, the required output is 22.

Input: arr[] = { -2, 11, -4, 2, -3, -10 }
Output: 13
Explanation:
Sum of the subsequence { arr[1], arr[3] } is equal to 13, which is the maximum possible sum of any subsequence of the array.
Therefore, the required output is 13.

Naive Approach: The simplest approach to solve this problem is to generate all possible non-empty subsequences of the array and calculate the sum of each subsequence of the array. Finally, print the maximum sum obtained from the subsequence.

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

Efficient Approach: The idea is to traverse the array and calculate the sum of positive elements of the array and print the sum obtained. Follow the steps below to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach``#include ``using` `namespace` `std;` `// Function to print the maximum``// non-empty subsequence sum``int` `MaxNonEmpSubSeq(``int` `a[], ``int` `n)``{``    ``// Stores the maximum non-empty``    ``// subsequence sum in an array``    ``int` `sum = 0;` `    ``// Stores the largest element``    ``// in the array``    ``int` `max = *max_element(a, a + n);` `    ``if` `(max <= 0) {` `        ``return` `max;``    ``}` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If a[i] is greater than 0``        ``if` `(a[i] > 0) {` `            ``// Update sum``            ``sum += a[i];``        ``}``    ``}``    ``return` `sum;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { -2, 11, -4, 2, -3, -10 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``cout << MaxNonEmpSubSeq(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;``class` `GFG``{` `  ``// Function to print the maximum``  ``// non-empty subsequence sum``  ``static` `int` `MaxNonEmpSubSeq(``int` `a[], ``int` `n)``  ``{` `    ``// Stores the maximum non-empty``    ``// subsequence sum in an array``    ``int` `sum = ``0``;` `    ``// Stores the largest element``    ``// in the array``    ``int` `max = a[``0``];``    ``for``(``int` `i = ``1``; i < n; i++)``    ``{``      ``if``(max < a[i])``      ``{``        ``max = a[i];``      ``}``    ``}` `    ``if` `(max <= ``0``) ``    ``{     ``      ``return` `max;``    ``}` `    ``// Traverse the array``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{` `      ``// If a[i] is greater than 0``      ``if` `(a[i] > ``0``) ``      ``{` `        ``// Update sum``        ``sum += a[i];``      ``}``    ``}``    ``return` `sum;``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `arr[] = { -``2``, ``11``, -``4``, ``2``, -``3``, -``10` `};``    ``int` `N = arr.length;` `    ``System.out.println(MaxNonEmpSubSeq(arr, N));``  ``}``}` `// This code is contributed by divyesh072019`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to print the maximum``# non-empty subsequence sum``def` `MaxNonEmpSubSeq(a, n):``    ` `    ``# Stores the maximum non-empty``    ``# subsequence sum in an array``    ``sum` `=` `0` `    ``# Stores the largest element``    ``# in the array``    ``maxm ``=` `max``(a)` `    ``if` `(maxm <``=` `0``):``        ``return` `maxm` `    ``# Traverse the array``    ``for` `i ``in` `range``(n):``        ` `        ``# If a[i] is greater than 0``        ``if` `(a[i] > ``0``):``            ` `            ``# Update sum``            ``sum` `+``=` `a[i]``            ` `    ``return` `sum` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ ``-``2``, ``11``, ``-``4``, ``2``, ``-``3``, ``-``10` `]``    ``N ``=` `len``(arr)` `    ``print``(MaxNonEmpSubSeq(arr, N))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program to implement``// the above approach``using` `System;` `class` `GFG{``    ` `// Function to print the maximum``// non-empty subsequence sum``static` `int` `MaxNonEmpSubSeq(``int``[] a, ``int` `n)``{``    ` `    ``// Stores the maximum non-empty``    ``// subsequence sum in an array``    ``int` `sum = 0;``    ` `    ``// Stores the largest element``    ``// in the array``    ``int` `max = a[0];``    ``for``(``int` `i = 1; i < n; i++)``    ``{``        ``if` `(max < a[i])``        ``{``            ``max = a[i];``        ``}``    ``}``    ` `    ``if` `(max <= 0) ``    ``{``        ``return` `max;``    ``}``    ` `    ``// Traverse the array``    ``for``(``int` `i = 0; i < n; i++) ``    ``{``        ` `        ``// If a[i] is greater than 0``        ``if` `(a[i] > 0)``        ``{``            ` `            ``// Update sum``            ``sum += a[i];``        ``}``    ``}``    ``return` `sum;``}` `// Driver Code``static` `void` `Main() ``{``    ``int``[] arr = { -2, 11, -4, 2, -3, -10 };``    ``int` `N = arr.Length;``    ` `    ``Console.WriteLine(MaxNonEmpSubSeq(arr, N));``}``}` `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``

Output:
`13`

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

Previous
Next