Maximum distinct elements after removing k elements

Difficulty Level : Medium
Last Updated : 16 Aug, 2021

Given an array arr[] containing n elements. The problem is to find the maximum number of distinct elements (non-repeating) after removing k elements from the array.
Note: 1 <= k <= n.
Examples:

Input : arr[] = {5, 7, 5, 5, 1, 2, 2}, k = 3
Output : 4
Remove 2 occurrences of element 5 and
1 occurrence of element 2.

Input : arr[] = {1, 2, 3, 4, 5, 6, 7}, k = 5
Output : 2

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

Approach: Following are the steps:

1. Make a multi set from the given array.

2. During making this multiset check if the current element is present or not in multiset, if it is already present then simply reduce the k value and donot insert in the multiset.

3. If k becomes 0 then simply just put values in multiset.

4. After traversing the whole given array,

a) if k is not equal to zero then it means the multiset is consist of only unique elements and we have to remove any of the k elements from the multiset to make k=0, so in this case the answer will be size of multiset minus k value at that time.

b) if k is equal to zero then it means there may be duplicate values present in the multiset so put all the values in a set and the size of this set will be the number of distinct elements after removing k elements

C++

// CPP implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
   
// function to find maximum distinct elements
// after removing k elements
int maxDistinctNum(int a[], int n, int k)
{
  int i;
  multiset<int> s;
  // making multiset from given array
        for(i=0;i<n;i++){
            if(s.find(a[i])==s.end()||k==0)
            s.insert(a[i]);
            else
            {
                k--;
            }
        }
   
        if(k!=0)
        return s.size()-k;
        else{
            set<int> st;
            for(auto it:s){
                st.insert(it);
            }
            return st.size();
        }
}
 
// Driver Code
int main()
{
    int arr[] = { 5, 7, 5, 5, 1, 2, 2 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 3;
   
    // Function Call
    cout << "Maximum distinct elements = "
         << maxDistinctNum(arr, n, k);
    return 0;
}

Java

// Java implementation of the
// above approach
import java.util.*;
class GFG{
     
// Function to find maximum
// distinct elements after
// removing k elements
static int maxDistinctNum(int arr[],
                          int n, int k)
{
  HashMap<Integer,
          Integer> numToFreq = new HashMap<>();
 
  // Build frequency map
  for(int i = 0 ; i < n ; i++)
  {
    numToFreq.put(arr[i],
    numToFreq.getOrDefault(arr[i], 0) + 1);
  }
 
  int result = 0;
 
  // Min-heap
  PriorityQueue<Integer> minHeap =
                new PriorityQueue<Integer>();
 
  // Add all number with freq=1 to
  // result and push others to minHeap
  for(Map.Entry<Integer,
                Integer> p : numToFreq.entrySet())
  {
    if(p.getValue() == 1)
      ++result;
    else
      minHeap.add(p.getValue());
  }
 
  // Perform k operations
  while(k != 0 && !minHeap.isEmpty())
  {
    // Pop the top() element
    Integer t = minHeap.poll();
     
    // Increment Result
    if(t == 1)
    {
      ++result;
    }
 
    // Reduce t and k
    // Push it again
    else
    {
      --t;
      --k;
      minHeap.add(t);
    }
  }
 
  // Return result
  return result;
}
 
// Driver code
public static void main(String[] args)
{       
  int arr[] = {5, 7, 5, 5, 1, 2, 2};
  int n = arr.length;
  int k = 3;
 
  // Function Call
  System.out.println("Maximum distinct elements = " + 
                      maxDistinctNum(arr, n, k));
}
}
 
// This code is contributed by rutvik_56

Javascript

<script>
 
// Javascript implementation of the above approach
   
// function to find maximum distinct elements
// after removing k elements
function maxDistinctNum(a, n, k)
{
  var i;
  var s = [];
  // making multiset from given array
        for(i=0;i<n;i++){
            if(!s.includes(a[i])||k==0)
            s.push(a[i]);
            else
            {
                k--;
            }
        }
   
        if(k!=0)
            return s.size-k;
        else{
            var st = new Set();
            s.forEach(element => {
                st.add(element);
            });
             
            return st.size;
        }
}
 
// Driver Code
var arr = [5, 7, 5, 5, 1, 2, 2];
var n = arr.length;
var k = 3;
 
// Function Call
document.write( "Maximum distinct elements = "
      +  maxDistinctNum(arr, n, k));
 
// This code is contributed by itsok.
</script>

Output:

Maximum distinct elements = 4

Time Complexity: O(k*logd), where d is the number of distinct elements in the given array.

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