Related Articles
Maximize subsequences having array elements not exceeding length of the subsequence
• Difficulty Level : Basic
• Last Updated : 12 Oct, 2020

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)

My Personal Notes arrow_drop_up