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

Form 4 subsequences of 1 which satisfy the given condition {1}, {1}, {1}, {1}.

Input:arr[] = {2, 2, 3, 1, 2, 1}Output:3Explanation:

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:

- Initialize a map to store the frequency of every array element.
- Initialize a variable, say
**count**to 0, to store the total number of subsequences obtained. - Keep track of the number of elements that are left to be added.
- Now, iterate over the map and count the number of elements that can be included in a particular group.
- Keep on adding the elements on the valid subsequences.
- 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 <bits/stdc++.h>` `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[0]);` ` ` `// 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<Integer,` ` ` `Integer> mp)` `{` ` ` ` ` `// Stores the number of subsequences` ` ` `int` `count = ` `0` `;` ` ` `int` `left = ` `0` `;` ` ` `// Iterate over the map` ` ` `for` `(Map.Entry<Integer, Integer> 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<Integer, Integer> 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)