# Count of subsequences having maximum distinct elements

• Difficulty Level : Medium
• Last Updated : 28 Jul, 2022

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

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.

Implementation:

## 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`

## Javascript

 ``

Output:

`Count = 2`

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

My Personal Notes arrow_drop_up