Skip to content
Related Articles

Related Articles

Improve Article

Length of the longest subsequence with negative sum of all prefixes

  • Difficulty Level : Hard
  • Last Updated : 29 Jun, 2021

Given an array arr[] consisting of N integers, the task is to find the length of the longest subsequence such that the prefix sum at each index of the subsequence is negative.

Examples:

Input: arr[] = {-1, -3, 3, -5, 8, 2}
Output: 5
Explanation: Longest subsequence satisfying the condition is {-1, -3, 3, -5, 2}.

Input: arr[] = {2, -5, 2, -1, 5, 1, -9, 10}
Output: 6
Explanation: Longest subsequence satisfying the condition is {-1, -3, 3, -5, 2}.

Approach: The problem can be solved by using a Priority Queue. Follow the steps below to solve the problem:



  • Initialize a priority queue, say pq, and a variable, say S as 0, to store the elements of the subsequence formed from elements up to an index i and to store the sum of the elements in the priority queue.
  • Iterate over the range [0, N – 1] using the variable i and perform the following steps:
  • Finally, after completing the above steps, print pq.size() as the answer.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the maximum length
// of a subsequence such that prefix sum
// of any index is negative
int maxLengthSubsequence(int arr[], int N)
{
    // Max priority Queue
    priority_queue<int> pq;
 
    // Stores the temporary sum of a
    // prefix of selected subsequence
    int S = 0;
 
    // Traverse the array arr[]
    for (int i = 0; i < N; i++) {
        // Increment S by arr[i]
        S += arr[i];
 
        // Push arr[i] into pq
        pq.push(arr[i]);
 
        // Iterate until S
        // is greater than 0
        while (S > 0) {
 
            // Decrement S by pq.top()
            S -= pq.top();
 
            // Pop the top element
            pq.pop();
        }
    }
 
    // Return the maxLength
    return pq.size();
}
 
// Driver Code
int main()
{
    // Given Input
    int arr[6] = { -1, -3, 3, -5, 8, 2 };
    int N = sizeof(arr) / sizeof(arr[0]);
    // Function call
    cout << maxLengthSubsequence(arr, N);
 
    return 0;
}


Java




// Java program for the above approach
import java.util.Collections;
import java.util.PriorityQueue;
 
public class GFG
{
 
    // Function to find the maximum length
    // of a subsequence such that prefix sum
    // of any index is negative
    static int maxLengthSubsequence(int arr[], int N)
    {
       
        // Max priority Queue
        PriorityQueue<Integer> pq = new PriorityQueue<>(
            Collections.reverseOrder());
 
        // Stores the temporary sum of a
        // prefix of selected subsequence
        int S = 0;
 
        // Traverse the array arr[]
        for (int i = 0; i < N; i++)
        {
           
            // Increment S by arr[i]
            S += arr[i];
 
            // Add arr[i] into pq
            pq.add(arr[i]);
 
            // Iterate until S
            // is greater than 0
            while (S > 0)
            {
 
                // Decrement S by pq.peek()
                S -= pq.peek();
 
                // Remove the top element
                pq.remove();
            }
        }
 
        // Return the maxLength
        return pq.size();
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { -1, -3, 3, -5, 8, 2 };
        int N = arr.length;
       
        // Function call
        System.out.println(maxLengthSubsequence(arr, N));
    }
}
 
// This code is contributed by abhinavjain194


Python3




# Python3 program for the above approach
 
# Function to find the maximum length
# of a subsequence such that prefix sum
# of any index is negative
def maxLengthSubsequence(arr, N):
     
    # Max priority Queue
    pq = []
 
    # Stores the temporary sum of a
    # prefix of selected subsequence
    S = 0
 
    # Traverse the array arr[]
    for i in range(N):
         
        # Increment S by arr[i]
        S += arr[i]
 
        # Push arr[i] into pq
        pq.append(arr[i])
 
        # Iterate until S
        # is greater than 0
        pq.sort(reverse = False)
         
        while (S > 0):
             
            # Decrement S by pq.top()
            # pq.sort(reverse=False)
            S = S - max(pq)
 
            # Pop the top element
            pq = pq[1:]
             
        # print(len(pq))
 
    # Return the maxLength
    return len(pq)
 
# Driver Code
if __name__ == '__main__':
     
    # Given Input
    arr = [ -1, -3, 3, -5, 8, 2 ]
    N = len(arr)
     
    # Function call
    print(maxLengthSubsequence(arr, N))
     
# This code is contributed by SURENDRA_GANGWAR


C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
  
// Function to find the maximum length
// of a subsequence such that prefix sum
// of any index is negative
static int maxLengthSubsequence(int []arr, int N)
{
    // Max priority Queue
    List<int> pq = new List<int>();
 
    // Stores the temporary sum of a
    // prefix of selected subsequence
    int S = 0;
 
    // Traverse the array arr[]
    for (int i = 0; i < N; i++)
    {
       
        // Increment S by arr[i]
        S += arr[i];
 
        // Push arr[i] into pq
        pq.Add(arr[i]);
         
        pq.Sort();
        // Iterate until S
        // is greater than 0
        while (S > 0) {
            pq.Sort();
            // Decrement S by pq.top()
            S -=  pq[pq.Count-1];
 
            // Pop the top element
            pq.RemoveAt(0);
        }
    }
 
    // Return the maxLength
    return pq.Count;
}
 
// Driver Code
public static void Main()
{
   
    // Given Input
    int []arr = { -1, -3, 3, -5, 8, 2 };
    int N = arr.Length;
   
    // Function call
    Console.Write(maxLengthSubsequence(arr, N));
     
}
}
 
// This code is contributed by ipg2016107.


Javascript




<script>
 
// JavaScript program for the above approach
 
// Function to find the maximum length
// of a subsequence such that prefix sum
// of any index is negative
function maxLengthSubsequence(arr, N) {
    // Max priority Queue
    let pq = new Array();
 
    // Stores the temporary sum of a
    // prefix of selected subsequence
    let S = 0;
 
    // Traverse the array arr[]
    for (let i = 0; i < N; i++) {
 
        // Increment S by arr[i]
        S += arr[i];
 
        // Push arr[i] into pq
        pq.push(arr[i]);
 
        pq.sort((a, b) => a - b);
        // Iterate until S
        // is greater than 0
        while (S > 0) {
            pq.sort((a, b) => a - b);
            // Decrement S by pq.top()
            S -= pq[pq.length - 1];
 
            // Pop the top element
            pq.shift();
        }
    }
 
    // Return the maxLength
    return pq.length;
}
 
// Driver Code
 
// Given Input
let arr = [-1, -3, 3, -5, 8, 2];
let N = arr.length;
 
// Function call
document.write(maxLengthSubsequence(arr, N));
 
// This code is contributed by gfgking
 
</script>


Output: 

5

 

Time Complexity: O(N*log(N))
Auxiliary Space: 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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :