# Maximize count of Decreasing Consecutive Subsequences from an Array

Last Updated : 29 Nov, 2022

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:
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 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 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

 ``

Output

`3`

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

Article Tags :
Practice Tags :