Maximize count of Decreasing Consecutive Subsequences from an Array

• Last Updated : 07 Oct, 2021

Given an array arr[] consisting of N integers, the task is to find the maximum count of decreasing subsequences possible from an array which satisfies the following conditions:

• Each subsequence is in its longest possible form.
• The difference between adjacent elements of the subsequence is always 1.

Examples:

Input: arr[] = {2, 1, 5, 4, 3}
Output:
Explanation:
Possible decreasing subsequences are { 5, 4, 3 } and { 2, 1 }.
Input: arr[] = {4, 5, 2, 1, 4}
Output:
Explanation:
Possible decreasing subsequences are { 4 }, { 5, 4} and { 2, 1}.

Approach:
The idea is to use a HashMap to solve the problem. Follow the steps below:

• Maintain a HashMap to store the count of subsequences possible for an array element and maxSubsequences to count the total number of possible subsequences.
• Traverse the array, and for each element arr[i], check if any subsequence exists which can have arr[i] as the next element, by the count assigned to arr[i] in the HashMap.
• If exists, do the following:
• Assign arr[i] as the next element of the subsequence.
• Decrease count assigned to arr[i] in the HashMap, as the number of possible subsequences with arr[i] as the next element has decreased by 1.
• Similarly, increase count assigned to arr[i] – 1 in the HashMap, as the number of possible subsequences with arr[i] – 1 as the next element has increased by 1.
• Otherwise, increase maxCount, as a new subsequence is required and repeat the above step to modify the HashMap.
• After completing the traversal of the array, print the value of maxCount.

C++

 // C++ program to implement// the above approach #include using namespace std; // Function to find the maximum number// number of required subsequencesint maxSubsequences(int arr[], int n){     // HashMap to store number of    // arrows available with    // height of arrow as key    unordered_map m;     // Stores the maximum count    // of possible subsequences    int maxCount = 0;     // Stores the count of    // possible subsequences    int count;     for (int i = 0; i < n; i++) {         // Check if i-th element can be        // part of any of the previous        // subsequence        if (m.find(arr[i]) != m.end()) {             // Count of subsequences            // possible with arr[i] as            // the next element            count = m[arr[i]];             // If more than one such            // subsequence exists            if (count > 1) {                 // Include arr[i] in a subsequence                m[arr[i]] = count - 1;            }             // Otherwise            else                m.erase(arr[i]);             // Increase count of subsequence possible            // with arr[i] - 1 as the next element            if (arr[i] - 1 > 0)                m[arr[i] - 1] += 1;        }        else {             // Start a new subsequence            maxCount++;             // Increase count of subsequence possible            // with arr[i] - 1 as the next element            if (arr[i] - 1 > 0)                m[arr[i] - 1] += 1;        }    }     // Return the answer    return maxCount;} // Driver Codeint main(){     int n = 5;     int arr[] = { 4, 5, 2, 1, 4 };     cout << maxSubsequences(arr, n) << endl;     // This code is contributed by bolliranadheer}

Java

 // Java program to implement// the above approachimport java.util.*;   class GFG {       // Function to find the maximum number    // number of required subsequences    static int maxSubsequences(int arr[], int n)    {           // HashMap to store number of        // arrows available with        // height of arrow as key        HashMap map            = new HashMap<>();           // Stores the maximum count        // of possible subsequences        int maxCount = 0;           // Stores the count of        // possible subsequences        int count;           for (int i = 0; i < n; i++)        {            // Check if i-th element can be            // part of any of the previous            // subsequence            if (map.containsKey(arr[i]))            {                // Count  of subsequences                // possible with arr[i] as                // the next element                count = map.get(arr[i]);                   // If more than one such                // subsequence exists                if (count > 1)                {                       // Include arr[i] in a subsequence                    map.put(arr[i], count - 1);                }                   // Otherwise                else                    map.remove(arr[i]);                   // Increase count of subsequence possible                // with arr[i] - 1 as the next element                if (arr[i] - 1 > 0)                    map.put(arr[i] - 1,                    map.getOrDefault(arr[i] - 1, 0) + 1);            }            else {                   // Start a new subsequence                maxCount++;                   // Increase count of subsequence possible                // with arr[i] - 1 as the next element                if (arr[i] - 1 > 0)                    map.put(arr[i] - 1,                    map.getOrDefault(arr[i] - 1, 0) + 1);            }        }           // Return the answer        return maxCount;    }       // Driver Code    public static void main(String[] args)    {        int n = 5;        int arr[] = { 4, 5, 2, 1, 4 };        System.out.println(maxSubsequences(arr, n));    }}

C#

 // C# program to implement// the above approachusing System;using System.Collections.Generic;  class GFG{   // Function to find the maximum number// number of required subsequencesstatic int maxSubsequences(int []arr, int n){         // Dictionary to store number of    // arrows available with    // height of arrow as key    Dictionary map = new Dictionary();                                              // Stores the maximum count    // of possible subsequences    int maxCount = 0;     // Stores the count of    // possible subsequences    int count;     for(int i = 0; i < n; i++)    {                 // Check if i-th element can be        // part of any of the previous        // subsequence        if (map.ContainsKey(arr[i]))        {                         // Count  of subsequences            // possible with arr[i] as            // the next element            count = map[arr[i]];             // If more than one such            // subsequence exists            if (count > 1)            {                                 // Include arr[i] in a subsequence                map.Add(arr[i], count - 1);            }             // Otherwise            else                map.Remove(arr[i]);             // Increase count of subsequence possible            // with arr[i] - 1 as the next element            if (arr[i] - 1 > 0)                if (map.ContainsKey(arr[i] - 1))                    map[arr[i] - 1]++;                else                    map.Add(arr[i] - 1, 1);        }        else        {                         // Start a new subsequence            maxCount++;             // Increase count of subsequence possible            // with arr[i] - 1 as the next element            if (arr[i] - 1 > 0)                if (map.ContainsKey(arr[i] - 1))                    map[arr[i] - 1]++;                else                    map.Add(arr[i] - 1, 1);        }    }     // Return the answer    return maxCount;} // Driver Codepublic static void Main(String[] args){    int n = 5;    int []arr = { 4, 5, 2, 1, 4 };         Console.WriteLine(maxSubsequences(arr, n));}} // This code is contributed by Amit Katiyar

Python3

 # Python program to implement# the above approach from collections import defaultdict # Function to find the maximum number# number of required subsequencesdef maxSubsequences(arr, n)->int:     # Dictionary to store number of    # arrows available with    # height of arrow as key    m = defaultdict(int)     # Stores the maximum count    # of possible subsequences    maxCount = 0     # Stores the count    # of possible subsequences    count = 0     for i in range(0, n):         # Check if i-th element can be        # part of any of the previous        # subsequence        if arr[i] in m.keys():             # Count of subsequences            # possible with arr[i] as            # the next element            count = m[arr[i]]             # If more than one such            # subsequence exists            if count > 1:                 # Include arr[i] in a subsequence                m[arr[i]] = count - 1             # Otherwise            else:                m.pop(arr[i])             # Increase count of subsequence possible            # with arr[i] - 1 as the next element            if arr[i] - 1 > 0:                m[arr[i] - 1] += 1         else:            maxCount += 1             # Increase count of subsequence possible            # with arr[i] - 1 as the next element            if arr[i] - 1 > 0:                m[arr[i] - 1] += 1     # Return the answer    return maxCount  # Driver Codeif __name__ == '__main__':    n = 5    arr = [4, 5, 2, 1, 4]    print(maxSubsequences(arr, n)) # This code is contributed by Riddhi Jaiswal.

Javascript


Output
3

My Personal Notes arrow_drop_up