Maximum distinct elements after removing k elements

// C# program to find maximum distinct
// elements after removing k elements
using System;
using System.Collections.Generic;

class GfG {
    
    // Function to find maximum distinct elements
    // after removing k elements
    static int maxDistinctNum(int[] arr, int k) {
        
        // Map to store the count of each 
        // value present in the array.
        Dictionary<int, int> map = new Dictionary<int, int>();

        foreach (int val in arr) {
            if (map.ContainsKey(val))
                map[val]++;
            else
                map[val] = 1;
        }
        
        // Max heap in order of higher
        // frequency.
        PriorityQueue<Pair> pq = new PriorityQueue<Pair>(new Comparer());
        
        // Traverse the map and value and 
        // its frequency into the heap 
        foreach (var p in map) {
            int val = p.Key;
            int freq = p.Value;
            pq.Enqueue(new Pair(freq, val));
        }

        int ans = 0;

        while (pq.Count > 0) {
            Pair top = pq.Dequeue();
            int freq = top.first;
            
            // Remove min(freq-1, k) occurrences
            // of val
            int toRemove = Math.Min(freq - 1, k);
            
            // Increment the distinct count.
            ans++;
            
            // Decrement k.
            k -= toRemove;
        }
        
        // If k > 0, we need to remove 
        // k distinct values.
        return ans - k;
    }

    static void Main() {
        int[] arr = { 5, 7, 5, 5, 1, 2, 2 };
        int k = 3;

        Console.WriteLine(maxDistinctNum(arr, k));
    }
}

class Pair {
    public int first, second;
    public Pair(int f, int s) {
        first = f;
        second = s;
    }
}

// Custom comparator class for max heap
class Comparer : IComparer<Pair> {
    public int Compare(Pair a, Pair b) {
        return a.first - b.first; 
    }
}

class PriorityQueue<T> {
    private List<T> heap;
    private IComparer<T> comparer;

    public PriorityQueue(IComparer<T> comparer) {
        this.heap = new List<T>();
        this.comparer = comparer;
    }

    public int Count => heap.Count;

    public void Enqueue(T item) {
        heap.Add(item);
        int i = heap.Count - 1;
        while (i > 0) {
            int parent = (i - 1) / 2;
            if (comparer.Compare(heap[parent], heap[i]) >= 0)
                break;
            Swap(parent, i);
            i = parent;
        }
    }

    public T Dequeue() {
        if (heap.Count == 0)
            throw new InvalidOperationException("Priority queue is empty.");
        T result = heap[0];
        int last = heap.Count - 1;
        heap[0] = heap[last];
        heap.RemoveAt(last);
        last--;
        int i = 0;
        while (true) {
            int left = 2 * i + 1;
            if (left > last)
                break;
            int right = left + 1;
            int maxChild = left;
            if (right <= last && comparer.Compare(heap[right], heap[left]) > 0)
                maxChild = right;
            if (comparer.Compare(heap[i], heap[maxChild]) >= 0)
                break;
            Swap(i, maxChild);
            i = maxChild;
        }
        return result;
    }

    private void Swap(int i, int j) {
        T temp = heap[i];
        heap[i] = heap[j];
        heap[j] = temp;
    }
}

// C# program to find maximum distinct 
// elements after removing k elements

using System;
using System.Collections.Generic;

class GfG {
    
    // function to find maximum distinct elements 
    // after removing k elements 
    static int maxDistinctNum(int[] arr, int k) {
        
        // Set to check if a value is 
        // already present or not. 
        HashSet<int> set = new HashSet<int>();
        
        for (int i = 0; i < arr.Length; i++) {
            
            // If value is already present in set 
            // and k > 0, decrement value of k.
            if (set.Contains(arr[i]) && k > 0) {
                k--;
            }
            
            // Else add the value to set 
            else {
                set.Add(arr[i]);
            }
        }
        
        // Set contains all the distinct values
        // If k > 0, we still need to remove k 
        // distinct values. Distinct values left 
        // will be equal to size of set minus k.
        return set.Count - k;
    }

    static void Main() {
        int[] arr = { 5, 7, 5, 5, 1, 2, 2 }; 
        int k = 3; 

        Console.WriteLine(maxDistinctNum(arr, k));
    }
}