Related Articles

# Count of subsequences having maximum distinct elements

• Difficulty Level : Medium
• Last Updated : 20 May, 2021

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.

## 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);``    ``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).

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up