# Count of subsequences having maximum distinct elements

Given an arr of size n. The problem is to count all the subsequences having maximum number of distinct elements.

Examples:

```Input : arr[] = {4, 7, 6, 7}
Output : 2
The indexes for the subsequences are:
{0, 1, 2} - Subsequence is {4, 7, 6} and
{0, 2, 3} - Subsequence is {4, 6, 7}

Input : arr[] = {9, 6, 4, 4, 5, 9, 6, 1, 2}
Output : 8
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive Approach: Consider all the subsequences having distinct elements and count the one’s having maximum distinct elements.

Efficient Approach: Create a hash table to store the frequency of each element of the array. Take product of all the frequencies.
The solution is based on the fact that there is always 1 subsequence possible when all elements are distinct. If elements repeat, every occurrence of repeating element makes a mew subsequence of distinct elements.

## C++

 `// C++ implementation to count subsequences having ` `// maximum distinct elements ` `#include ` `using` `namespace` `std; ` ` `  `typedef` `unsigned ``long` `long` `int` `ull; ` ` `  `// function to count subsequences having ` `// maximum distinct elements ` `ull countSubseq(``int` `arr[], ``int` `n) ` `{ ` `    ``// unordered_map 'um' implemented as ` `    ``// hash table ` `    ``unordered_map<``int``, ``int``> um; ` ` `  `    ``ull count = 1; ` ` `  `    ``// count frequency of each element ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``um[arr[i]]++; ` ` `  `    ``// traverse 'um' ` `    ``for` `(``auto` `itr = um.begin(); itr != um.end(); itr++) ` ` `  `        ``// multiply frequency of each element ` `        ``// and accumulate it in 'count' ` `        ``count *= (itr->second); ` ` `  `    ``// required number of subsequences ` `    ``return` `count; ` `} ` ` `  `// Driver program to test above ` `int` `main() ` `{ ` `    ``int` `arr[] = { 4, 7, 6, 7 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]); ` `    ``cout << ``"Count = "` `         ``<< countSubseq(arr, n); ` `    ``return` `0; ` `} `

## Java

 `// Java implementation to count subsequences having  ` `// maximum distinct elements ` `import` `java.util.HashMap; ` ` `  `class` `geeks ` `{ ` `     `  `    ``// function to count subsequences having ` `    ``// maximum distinct elements ` `    ``public` `static` `long` `countSubseq(``int``[] arr, ``int` `n)  ` `    ``{ ` ` `  `        ``// unordered_map 'um' implemented as ` `        ``// hash table ` `        ``HashMap um = ``new` `HashMap<>(); ` ` `  `        ``long` `count = ``1``; ` ` `  `        ``// count frequency of each element ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``{ ` `            ``if` `(um.get(arr[i]) != ``null``) ` `            ``{ ` `                ``int` `a = um.get(arr[i]); ` `                ``um.put(arr[i], ++a); ` `            ``} ` `            ``else` `                ``um.put(arr[i], ``1``); ` `        ``} ` `         `  `        ``// traverse 'um' ` `        ``for` `(HashMap.Entry entry : um.entrySet()) ` `        ``{ ` `             `  `            ``// multiply frequency of each element ` `            ``// and accumulate it in 'count' ` `            ``count *= entry.getValue(); ` `        ``} ` `         `  `        ``// required number of subsequences ` `        ``return` `count; ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``int``[] arr = { ``4``, ``7``, ``6``, ``7` `}; ` `        ``int` `n = arr.length; ` `        ``System.out.println(``"Count = "` `+ countSubseq(arr, n)); ` `    ``} ` `} ` ` `  `// This code is contributed by ` `// sanjeev2552 `

## Python3

 `# Python 3 implementation to count subsequences  ` `# having maximum distinct elements ` ` `  `# function to count subsequences having ` `# maximum distinct elements ` `def` `countSubseq(arr, n): ` `     `  `    ``# unordered_map 'um' implemented ` `    ``# as hash table ` `    ``# take range equal to maximum  ` `    ``# value of arr ` `    ``um ``=` `{i:``0` `for` `i ``in` `range``(``8``)} ` ` `  `    ``count ``=` `1` ` `  `    ``# count frequency of each element ` `    ``for` `i ``in` `range``(n): ` `        ``um[arr[i]] ``+``=` `1` ` `  `    ``# traverse 'um' ` `    ``for` `key, values ``in` `um.items(): ` `         `  `        ``# multiply frequency of each element ` `        ``# and accumulate it in 'count' ` `        ``if``(values > ``0``): ` `            ``count ``*``=` `values ` ` `  `    ``# required number of subsequences ` `    ``return` `count ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``arr ``=` `[``4``, ``7``, ``6``, ``7``] ` `    ``n ``=` `len``(arr) ` `    ``print``(``"Count ="``, countSubseq(arr, n)) ` ` `  `# This code is contributed by ` `# Surendra_Gangwar `

## C#

 `// C# implementation to count subsequences ` `// having maximum distinct elements ` `using` `System; ` `using` `System.Collections.Generic;  ` `     `  `class` `GFG ` `{ ` `     `  `    ``// function to count subsequences having ` `    ``// maximum distinct elements ` `    ``public` `static` `long` `countSubseq(``int``[] arr, ` `                                   ``int` `n)  ` `    ``{ ` ` `  `        ``// unordered_map 'um' implemented as ` `        ``// hash table ` `        ``Dictionary<``int``,  ` `                   ``int``> um = ``new` `Dictionary<``int``, ` `                                            ``int``>(); ` ` `  `        ``long` `count = 1; ` ` `  `        ``// count frequency of each element ` `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{ ` `            ``if` `(um.ContainsKey(arr[i])) ` `            ``{ ` `                ``int` `a = um[arr[i]]; ` `                ``um.Remove(arr[i]); ` `                ``um.Add(arr[i], ++a); ` `            ``} ` `            ``else` `                ``um.Add(arr[i], 1); ` `        ``} ` `         `  `        ``// traverse 'um' ` `        ``foreach``(KeyValuePair<``int``, ``int``> entry ``in` `um) ` `        ``{ ` `             `  `            ``// multiply frequency of each element ` `            ``// and accumulate it in 'count' ` `            ``count *= entry.Value; ` `        ``} ` `         `  `        ``// required number of subsequences ` `        ``return` `count; ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{ ` `        ``int``[] arr = { 4, 7, 6, 7 }; ` `        ``int` `n = arr.Length; ` `        ``Console.WriteLine(``"Count = "` `+  ` `                           ``countSubseq(arr, n)); ` `    ``} ` `} ` ` `  `// This code is contributed by Princi Singh `

Output:

```Count = 2
```

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

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.