Open In App
Related Articles

Maximum distinct elements after removing k elements

Improve Article
Improve
Save Article
Save
Like Article
Like

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: 

  • Make a multi set from the given array.
  • 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 do not insert in the multiset.
  • If k becomes 0 then simply just put values in multiset.
  • After traversing the whole given array, 
    • 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.
    • 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

Below is the implementation of the above approach:

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


Python3




# Python implementation of the above approach
 
# function to find maximum distinct elements after removing k elements
def maxDistinctNum(a, n, k):
   
   # making multiset from given array multisets are like dictionaries ,
   # so will initialise a dictionary
    s = {}
    for i in range(n):
        if a[i] not in s or k == 0:
            s[a[i]] = s.get(a[i], 0)+1
        else:
            s[a[i]] = 1
            k -= 1
    if k != 0:
        return len(s)-k
    else:
 
        st = set()
        for i in s:
            st.add(i)
        return len(st)
 
# Driver Code
if __name__ == "__main__":
 
  # Array
    arr = [5, 7, 5, 5, 1, 2, 2]
    K = 3
 
    # Size of array
    N = len(arr)
     
    # Function Call
    print("Maximum distinct elements = ", maxDistinctNum(arr, N, K))
 
# This code is contributed by vivekmaddheshiya205


C#




using System;
using System.Linq;
using System.Collections.Generic;
 
class MainClass {
    public static int maxDistinctNum(int[] a, int n, int k) {
        HashSet<int> s = new HashSet<int>();
        for(int i=0;i<n;i++){
            if(!s.Contains(a[i]) || k==0)
            s.Add(a[i]);
            else
            {
                k--;
            }
        }
 
        if(k!=0)
        return s.Count()-k;
        else{
            return s.Distinct().Count();
        }
    }
 
    public static void Main (string[] args) {
        int[] arr = { 5, 7, 5, 5, 1, 2, 2 };
        int n = arr.Length;
        int k = 3;
 
        Console.WriteLine("Maximum distinct elements = " + maxDistinctNum(arr, n, k));
    }
}


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.
Auxiliary Space: O(N), because we are using multiset.

Another Approach: Follow the below steps, to solve this problem:

  • Find the Number of distinct Toys.
  • Sum of number of element except one element form every distinct Toys.
  • Check sum if greater than or equal K then Return all distinct element.
  • Otherwise decrement number of distinct element and to fill K.
  • Return Size of vector.

Below is the implementation of the above approach:

C++




// C++ code for the above approach
#include <bits/stdc++.h>
using namespace std;
// function to return maximum number of distinct Toys
int MaxNumber(int arr[], int N, int K)
{
    // Count Number of distinct Number
    unordered_map<int, int> mp;
    for (int i = 0; i < N; i++) {
        mp[arr[i]]++;
    }
    // push them into vector
    vector<int> v1;
    for (auto i : mp) {
        v1.push_back(i.second);
    }
    // add number of element except one element from every
    // distinct element
    int temp = 0;
    for (int i = 0; i < v1.size(); i++) {
        temp += v1[i] - 1;
    }
    // check if it is greater than simply return size of
    // vector otherwise decrement size of vector to fill k
    if (K <= temp) {
        return v1.size();
    }
    else {
        K = K - temp;
        int ans = v1.size();
        while (K) {
            ans--;
            K--;
        }
        return ans;
    }
}
// Driver Code
int main()
{
    // array
    int arr[] = { 10, 10, 10, 50, 50 };
    int K = 3;
    // size of array
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << MaxNumber(arr, N, K) << endl;
    return 0;
}


Java




// Java code for the above approach
import java.io.*;
import java.util.*;
 
class GFG {
 
  // Function to return maximum number of distinct Toys
  static int MaxNumber(int[] arr, int N, int K)
  {
 
    // Count Number of distinct Number
    HashMap<Integer, Integer> mp = new HashMap<>();
    for (int i = 0; i < N; i++) {
      mp.put(arr[i], mp.getOrDefault(arr[i], 0) + 1);
    }
 
    // pust them into arraylist
    List<Integer> v1 = new ArrayList<>();
    for (Map.Entry<Integer, Integer> i :
         mp.entrySet()) {
      v1.add(i.getValue());
    }
 
    // add number of element except one element from
    // every distinct element
    int temp = 0;
    for (int i = 0; i < v1.size(); i++) {
      temp += v1.get(i) - 1;
    }
 
    // check if it is greater than simply return size of
    // vector otherwise decrement size of vector to fill
    // k
    if (K <= temp) {
      return v1.size();
    }
    else {
      K = K - temp;
      int ans = v1.size();
      while (K != 0) {
        ans--;
        K--;
      }
      return ans;
    }
  }
 
  public static void main(String[] args)
  {
    int arr[] = { 10, 10, 10, 50, 50 };
    int K = 3;
    int N = arr.length;
 
    System.out.println(MaxNumber(arr, N, K));
  }
}
 
// This code is contributed by lokeshmvs21.


Python3




# Python3 code for the above approach
 
# function to return maximum number of distinct Toys
def MaxNumber(arr, N, K):
   
    # Count Number of distinct Number
    mp = {}
    for i in range(N):
        if arr[i] not in mp:
            mp[arr[i]] = 0
        mp[arr[i]] += 1
         
        # push them into vector
    v1 = []
    for i in mp:
        v1.append(mp[i])
 
     # add number of element except one element from every
    # distinct element
    temp = 0
    for i in range(len(v1)):
        temp += v1[i]-1
         
     # check if it is greater than simply return size of
    # vector otherwise decrement size of vector to fill k
    if K <= temp:
        return len(v1)
    else:
        K = K-temp
        ans = len(v1)
        while K:
            ans -= 1
            K -= 1
        return ans
 
# Driver Code
if __name__ == "__main__":
   
  # Array
    arr = [10, 10, 10, 50, 50]
    K = 3
     
    # Size of array
    N = len(arr)
    print(MaxNumber(arr, N, K))
 
    # This code is contributed by vivekmaddheshiya205


C#




// C# code for the above approach
 
using System;
using System.Collections;
using System.Collections.Generic;
 
public class GFG {
 
    // Function to return maximum number of distinct Toys
    static int MaxNumber(int[] arr, int N, int K)
    {
        // Count Number of distinct Number
        Dictionary<int, int> mp
            = new Dictionary<int, int>();
 
        for (int i = 0; i < N; i++) {
            if (mp.ContainsKey(arr[i])) {
                mp[arr[i]]++;
            }
            else {
                mp.Add(arr[i], 1);
            }
        }
 
        // put them into arraylist
        ArrayList v1 = new ArrayList();
        foreach(KeyValuePair<int, int> i in mp)
        {
            v1.Add(i.Value);
        }
 
        // add number of element except one element from
        // every distinct element
        int temp = 0;
        for (int i = 0; i < v1.Count; i++) {
            temp += (int)v1[i] - 1;
        }
 
        // check if it is greater than simply return size of
        // vector otherwise decrement size of vector to fill
        // k
        if (K <= temp) {
            return v1.Count;
        }
        else {
            K = K - temp;
            int ans = v1.Count;
            while (K != 0) {
                ans--;
                K--;
            }
            return ans;
        }
    }
 
    static public void Main()
    {
 
        // Code
        int[] arr = { 10, 10, 10, 50, 50 };
        int K = 3;
        int N = arr.Length;
 
        Console.WriteLine(MaxNumber(arr, N, K));
    }
}
 
// This code is contributed by lokesh


Javascript




<script>
function MaxNumber(arr, N, K) {
  // Count Number of distinct Number
  let mp = new Map();
  for (let i = 0; i < N; i++) {
    if (mp.has(arr[i])) {
      mp.set(arr[i], mp.get(arr[i]) + 1);
    } else {
      mp.set(arr[i], 1);
    }
  }
  // push them into array
  let v1 = [];
  for (let i of mp) {
    v1.push(i[1]);
  }
  // add number of element except one element from every
  // distinct element
  let temp = 0;
  for (let i = 0; i < v1.length; i++) {
    temp += v1[i] - 1;
  }
  // check if it is greater than simply return size of
  // array otherwise decrement size of array to fill k
  if (K <= temp) {
    return v1.length;
  } else {
    K = K - temp;
    let ans = v1.length;
    while (K) {
      ans--;
      K--;
    }
    return ans;
  }
}
 
// Test
let arr = [10, 10, 10, 50, 50];
let K = 3;
// size of array
let N = arr.length;
console.log(MaxNumber(arr, N, K));
 
</script>


Output

2

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


Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Last Updated : 22 Jan, 2023
Like Article
Save Article
Previous
Next
Similar Reads
Complete Tutorials