# Minimum number of distinct elements present in a K-length subsequence in an array

Last Updated : 30 Jan, 2023

Given an array A[] consisting of N integers and an integer K, the task is to count the minimum number of distinct elements present in a subsequence of length K of the given array, A.

Examples:

Input: A = {3, 1, 3, 2, 3, 4, 5, 4}, K = 4
Output: 2
Explanation: The subsequence of length 4 containing minimum number of distinct elements is {3, 3, 3, 4}, consisting of 2 distinct elements, i.e. {3, 4}.

Input: A = {3, 1, 3, 2, 3, 4, 5, 4}, K = 5
Output: 2
Explanation: The subsequence of length 5 containing minimum number of distinct elements is {3, 3, 3, 4, 4}, consisting of 2 distinct elements, i.e. {3, 4}.

Naive Approach: The simplest approach is to generate all subsequences of length K and for each subsequence, find the number of distinct elements present in them. Finally, print the minimum number of distinct elements present.

Time Complexity: O(K * NK)
Auxiliary Space: O(N)

Efficient Approach: The above approach can be optimized using Hashing. Follow the steps below to solve the problem:

Below is the implementation of the above approach:

## C++

 // C++ program for the above approach #include using namespace std;   // Function to count the minimum number // of distinct elements present in any // subsequence of length K of the given array void findMinimumDistinct(int A[], int N, int K) {       // Stores the frequency     // of each array element     unordered_map mp;       // Traverse the array     for (int i = 0; i < N; i++)           // Update frequency         // of array elements         mp[A[i]]++;       // Store the required result     int count = 0;       // Store the length of the     // required subsequence     int len = 0;       // Store the frequencies     // in decreasing order     vector counts;       // Traverse the map     for (auto i : mp)           // Push the frequencies         // into the HashMap         counts.push_back(i.second);       // Sort the array in decreasing order     sort(counts.begin(), counts.end(),          greater());       // Add the elements into the subsequence     // starting from one with highest frequency     for (int i = 0; i < counts.size(); i++) {           // If length of subsequence is >= k         if (len >= K)             break;         len += counts[i];         count++;     }       // Print the result     cout << count; }   // Driver Code int main() {     int A[] = { 3, 1, 3, 2, 3, 4, 5, 4 };     int K = 4;       // Store the size of the array     int N = sizeof(A) / sizeof(A[0]);       // Function Call to count minimum     // number of distinct elements     // present in a K-length subsequence     findMinimumDistinct(A, N, K);       return 0; }

## Java

 // Java program for the above approach import java.util.*;   class GFG{   // Function to count the minimum number // of distinct elements present in any // subsequence of length K of the given array static void findMinimumDistinct(int A[], int N, int K) {           // Stores the frequency     // of each array element     Map mp = new HashMap<>();       // Traverse the array     for(int i = 0; i < N; i++)               // Update frequency         // of array elements         mp.put(A[i], mp.getOrDefault(A[i], 0) + 1);       // Store the required result     int count = 0;       // Store the length of the     // required subsequence     int len = 0;       // Store the frequencies     // in decreasing order     ArrayList counts = new ArrayList<>();       // Traverse the map     for(Map.Entry i : mp.entrySet())               // Push the frequencies         // into the HashMap         counts.add(i.getValue());       // Sort the array in decreasing order     Collections.sort(counts, (a, b) -> b - a);       // Add the elements into the subsequence     // starting from one with highest frequency     for(int i = 0; i < counts.size(); i++)     {                   // If length of subsequence is >= k         if (len >= K)             break;                       len += counts.get(i);         count++;     }       // Print the result     System.out.print(count); }   // Driver code public static void main(String[] args) {     int A[] = { 3, 1, 3, 2, 3, 4, 5, 4 };     int K = 4;       // Store the size of the array     int N = A.length;       // Function Call to count minimum     // number of distinct elements     // present in a K-length subsequence     findMinimumDistinct(A, N, K); } }   // This code is contributed by offbeat

## Python3

 # Python3 program for the above approach from collections import Counter   # Function to count the minimum number # of distinct elements present in any # subsequence of length K of the given array def findMinimumDistinct(A, N, K):           # Stores the frequency     # of each array element     mp = Counter(A)           # Store the required result     count = 0           # Store the length of the     # required subsequence     length = 0           # Store the frequencies     # in decreasing order     counts = []           # Traverse the map     for i in mp:                   # Push the frequencies         # into the HashMap         counts.append(mp[i])               # Sort the array in decreasing order     counts = sorted(counts)     counts.reverse()           # Add the elements into the subsequence     # starting from one with highest frequency     for i in range(len(counts)):                   # If length of subsequence is >= k         if (length >= K):             break                   length += counts[i]         count += 1               # Print the result     print(count)   # Driver Code A = [3, 1, 3, 2, 3, 4, 5, 4] K = 4   # Store the size of the array N = len(A)   # Function Call to count minimum # number of distinct elements # present in a K-length subsequence findMinimumDistinct(A, N, K)   # This code is contributed by sudhanshugupta2019a

## C#

 // C# program for the above approach using System; using System.Collections.Generic;   class Program {   static void Main(string[] args)   {     int[] A = new int[] { 3, 1, 3, 2, 3, 4, 5, 4 };     int K = 4;     int N = A.Length;       Console.WriteLine(FindMinimumDistinct(A, N, K));   }     static int FindMinimumDistinct(int[] A, int N, int K)   {     Dictionary mp = new Dictionary();     foreach (var item in A)     {       if (mp.ContainsKey(item))         mp[item]++;       else         mp[item] = 1;     }       int count = 0;     int length = 0;     List counts = new List();     foreach (var item in mp)       counts.Add(item.Value);       counts.Sort();     counts.Reverse();       for (int i = 0; i < counts.Count; i++)     {       if (length >= K)         break;       length += counts[i];       count++;     }       return count;   } }   // This code is contributed by shivamsharma215

## Javascript



Output:

2

Time Complexity: O(N*log(N))
Auxiliary Space: O(N)