GFG App
Open App
Browser
Continue

# 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)

My Personal Notes arrow_drop_up