# Maximize subsequences having array elements not exceeding length of the subsequence

Given an array arr[] consisting of N positive integers, the task is to maximize the number of subsequences that can be obtained from an array such that every element arr[i] that is part of any subsequence does not exceed the length of that subsequence.

Examples:

Input: arr[] = {1, 1, 1, 1}
Output:
Explanation:
Form 4 subsequences of 1 which satisfy the given condition {1}, {1}, {1}, {1}.

Input: arr[] = {2, 2, 3, 1, 2, 1}
Output:
Explanation:
The possible group are {1}, {1}, {2, 2}
So, the output is 3.

Approach: The idea is to use Greedy Technique to solve this problem. Follow the steps below to solve the problem:

1. Initialize a map to store the frequency of every array element.
2. Initialize a variable, say count to 0, to store the total number of subsequences obtained.
3. Keep track of the number of elements that are left to be added.
4. Now, iterate over the map and count the number of elements that can be included in a particular group.
5. Keep on adding the elements on the valid subsequences.
6. After completing the above steps, print the count of subsequences.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to calculate the number` `// of subsequences that can be formed` `int` `No_Of_subsequences(map<``int``, ``int``> mp)` `{` `    ``// Stores the number of subsequences` `    ``int` `count = 0;` `    ``int` `left = 0;`   `    ``// Iterate over the map` `    ``for` `(``auto` `x : mp) {`   `        ``x.second += left;`   `        ``// Count the number of subsequences` `        ``// that can be formed from x.first` `        ``count += (x.second / x.first);`   `        ``// Number of occurrences of` `        ``// x.first which are left` `        ``left = x.second % x.first;` `    ``}`   `    ``// Return the number of subsequences` `    ``return` `count;` `}`   `// Function to create the maximum count` `// of subsequences that can be formed` `void` `maximumsubsequences(``int` `arr[], ``int` `n)` `{` `    ``// Stores the frequency of arr[]` `    ``map<``int``, ``int``> mp;`   `    ``// Update the frequency` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``mp[arr[i]]++;`   `    ``// Print the number of subsequences` `    ``cout << No_Of_subsequences(mp);` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given array arr[]` `    ``int` `arr[] = { 1, 1, 1, 1 };`   `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);`   `    ``// Function Call` `    ``maximumsubsequences(arr, N);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach ` `import` `java.util.*;`   `class` `GFG{` `    `  `// Function to calculate the number` `// of subsequences that can be formed` `public` `static` `int` `No_Of_subsequences(HashMap mp)` `{` `    `  `    ``// Stores the number of subsequences` `    ``int` `count = ``0``;` `    ``int` `left = ``0``;`   `    ``// Iterate over the map` `    ``for``(Map.Entry x : mp.entrySet()) ` `    ``{` `        ``mp.replace(x.getKey(), x.getValue() + left);` `        `  `        ``// Count the number of subsequences` `        ``// that can be formed from x.first` `        ``count += (x.getValue() / x.getKey());`   `        ``// Number of occurrences of` `        ``// x.first which are left` `        ``left = x.getValue() % x.getKey();` `    ``}`   `    ``// Return the number of subsequences` `    ``return` `count;` `}`   `// Function to create the maximum count` `// of subsequences that can be formed` `public` `static` `void` `maximumsubsequences(``int``[] arr, ` `                                       ``int` `n)` `{` `    `  `    ``// Stores the frequency of arr[]` `    ``HashMap mp = ``new` `HashMap<>(); `   `    ``// Update the frequency` `    ``for``(``int` `i = ``0``; i < n; i++)` `    ``{` `        ``if` `(mp.containsKey(arr[i]))` `        ``{` `            ``mp.replace(arr[i], mp.get(arr[i]) + ``1``);` `        ``}` `        ``else` `        ``{` `            ``mp.put(arr[i], ``1``); ` `        ``}` `    ``}`   `    ``// Print the number of subsequences` `    ``System.out.println(No_Of_subsequences(mp));` `} `   `// Driver code` `public` `static` `void` `main(String[] args) ` `{` `    `  `    ``// Given array arr[]` `    ``int` `arr[] = { ``1``, ``1``, ``1``, ``1` `};`   `    ``int` `N = arr.length;`   `    ``// Function call` `    ``maximumsubsequences(arr, N);` `}` `}`   `// This code is contributed divyeshrabadiya07`

## Python3

 `# Python3 program for ` `# the above approach` `from` `collections ``import` `defaultdict`   `# Function to calculate ` `# the number of subsequences ` `# that can be formed` `def` `No_Of_subsequences(mp):`   `    ``# Stores the number ` `    ``# of subsequences` `    ``count ``=` `0` `    ``left ``=` `0`   `    ``# Iterate over the map` `    ``for` `x ``in` `mp:`   `        ``mp[x] ``+``=` `left`   `        ``# Count the number of ` `        ``# subsequences that can ` `        ``# be formed from x.first` `        ``count ``+``=` `(mp[x] ``/``/` `x)`   `        ``# Number of occurrences of` `        ``# x.first which are left` `        ``left ``=` `mp[x] ``%` `x` `   `  `    ``# Return the number ` `    ``# of subsequences` `    ``return` `count`   `# Function to create the ` `# maximum count of subsequences ` `# that can be formed` `def` `maximumsubsequences(arr, n):`   `    ``# Stores the frequency of arr[]` `    ``mp ``=` `defaultdict (``int``)`   `    ``# Update the frequency` `    ``for` `i ``in` `range` `(n):` `        ``mp[arr[i]] ``+``=` `1`   `    ``# Print the number of subsequences` `    ``print``(No_Of_subsequences(mp))`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `  `  `    ``# Given array arr[]` `    ``arr ``=` `[``1``, ``1``, ``1``, ``1``]`   `    ``N ``=` `len``(arr)`   `    ``# Function Call` `    ``maximumsubsequences(arr, N)`   `# This code is contributed by Chitranayal`

## C#

 `// C# program for ` `// the above approach ` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{` `    `  `// Function to calculate the number` `// of subsequences that can be formed` `public` `static` `int` `No_Of_subsequences(Dictionary<``int``, ` `                                                ``int``> mp)` `{` `  ``// Stores the number ` `  ``// of subsequences` `  ``int` `count = 0;` `  ``int` `left = 0;`   `  ``// Iterate over the map` `  ``foreach``(KeyValuePair<``int``, ` `                       ``int``> x ``in` `mp) ` `  ``{` `    ``if``(!mp.ContainsKey(x.Key))` `      ``mp.Add(x.Key, x.Value + left);`   `    ``// Count the number of subsequences` `    ``// that can be formed from x.first` `    ``count += (x.Value / x.Key);`   `    ``// Number of occurrences of` `    ``// x.first which are left` `    ``left = x.Value % x.Key;` `  ``}`   `  ``// Return the number of subsequences` `  ``return` `count;` `}`   `// Function to create the maximum count` `// of subsequences that can be formed` `public` `static` `void` `maximumsubsequences(``int``[] arr, ` `                                       ``int` `n)` `{` `  ``// Stores the frequency of []arr` `  ``Dictionary<``int``, ` `             ``int``> mp = ``new` `Dictionary<``int``, ` `                                      ``int``>(); ` `  `  `  ``// Update the frequency` `  ``for``(``int` `i = 0; i < n; i++)` `  ``{` `    ``if` `(mp.ContainsKey(arr[i]))` `    ``{` `      ``mp[arr[i]] =  mp[arr[i]] + 1;` `    ``}` `    ``else` `    ``{` `      ``mp.Add(arr[i], 1); ` `    ``}` `  ``}`   `  ``// Print the number of subsequences` `  ``Console.WriteLine(No_Of_subsequences(mp));` `} `   `// Driver code` `public` `static` `void` `Main(String[] args) ` `{` `  ``// Given array []arr` `  ``int` `[]arr = {1, 1, 1, 1};`   `  ``int` `N = arr.Length;`   `  ``// Function call` `  ``maximumsubsequences(arr, N);` `}` `}`   `// This code is contributed by Rajput-Ji`

Output:

```4

```

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.