Maximize count of Decreasing Consecutive Subsequences from an Array

Given an array arr[] consisting of N integers, the task is to find the maximum count of decreasing subsequences possible from an array that 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: 2 
Explanation: 
Possible decreasing subsequences are { 5, 4, 3 } and { 2, 1 }.
Input: arr[] = {4, 5, 2, 1, 4} 
Output: 3 
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 <bits/stdc++.h>
using namespace std;

// Function to find the maximum number
// number of required subsequences
int maxSubsequences(int arr[], int n)
{

    // HashMap to store number of
    // arrows available with
    // height of arrow as key
    unordered_map<int, int> 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 Code
int 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 approach
import 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<Integer, Integer> 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 approach
using System;
using System.Collections.Generic;

class GFG{

// Function to find the maximum number
// number of required subsequences
static int maxSubsequences(int []arr, int n)
{

    // Dictionary to store number of
    // arrows available with
    // height of arrow as key
    Dictionary<int,
               int> map = new Dictionary<int,
                                         int>();

    // 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 Code
public 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 subsequences
def 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 Code
if __name__ == '__main__':
    n = 5
    arr = [4, 5, 2, 1, 4]
    print(maxSubsequences(arr, n))

# This code is contributed by Riddhi Jaiswal.

Javascript

<script>

// Javascript program to implement
// the above approach

// Function to find the maximum number
// number of required subsequences
function maxSubsequences(arr, n)
{

    // Dictionary to store number of
    // arrows available with
    // height of arrow as key
    let map = new Map();

    // Stores the maximum count
    // of possible subsequences
    let maxCount = 0;

    // Stores the count of
    // possible subsequences
    let count;

    for(let i = 0; i < n; i++)
    {

        // Check if i-th element can be
        // part of any of the previous
        // subsequence
        if (map.has(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.delete(arr[i]);

            // Increase count of subsequence possible
            // with arr[i] - 1 as the next element
            if (arr[i] - 1 > 0)
                if (map.has(arr[i] - 1))
                    map[arr[i] - 1]++;
                else
                    map.set(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.has(arr[i] - 1))
                    map[arr[i] - 1]++;
                else
                    map.set(arr[i] - 1, 1);
        }
    }

    // Return the answer
    return maxCount;
}

// Driver code

    let n = 5;
    let arr = [ 4, 5, 2, 1, 4 ];

    document.write(maxSubsequences(arr, n));

</script>

Output

3

Time Complexity: O(n)
Auxiliary Space: O(n)