Minimum removals required to make frequency of each array element equal to its value

Given an array arr[] of size N, the task is to find the minimum count of array elements required to be removed such that frequency of each array element is equal to its value

Examples:

Input: arr[] = { 2, 4, 1, 4, 2 } 
Output: 2 
Explanation: 
Removing arr[1] from the array modifies arr[] to { 2, 1, 4, 2 } 
Removing arr[2] from the array modifies arr[] to { 2, 1, 2 } 
Distinct elements in the array are: { 1, 2 } with frequencies 1 and 2 respectively. 
Therefore, the required output is 2.

Input: arr[] = { 2, 7, 1, 8, 2, 8, 1, 8 } 
Output: 5

Approach: The problem can be solved using Greedy technique. Follow the steps below to solve the problem:

• Initialize a map say, mp to store the frequency of each distinct element of the array.
• Traverse the array and store the frequency of each distinct element of the array.
• Initialize a variable say, cntMinRem to store the minimum count of array elements required to be removed such that the frequency of arr[i] is equal to arr[i].
• Traverse the map using key value of the map as i and check the following conditions: 
  • If mp[i] < i, then update the value of cntMinRem += mp[i].
  • If mp[i] > i, then update the value of cntMinRem += (mp[i] – i). 
    
• Finally, print the value of cntMinRem.

Below is the implementation of the above approach:

C++14

// C++ program to implement
// the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find the minimum count of
// elements required to be removed such
// that frequency of arr[i] equal to arr[i]
int min_elements(int arr[], int N)
{
    // Stores frequency of each
    // element of the array
    unordered_map<int, int> mp;

    // Traverse the array
    for (int i = 0; i < N; i++) {

        // Update frequency
        // of arr[i]
        mp[arr[i]]++;
    }

    // Stores minimum count of removals
    int cntMinRem = 0;

    // Traverse the map
    for (auto it : mp) {

        // Stores key value
        // of the map
        int i = it.first;

        // If frequency of i is
        // less than i
        if (mp[i] < i) {

            // Update cntMinRem
            cntMinRem += mp[i];
        }

        // If frequency of i is
        // greater than i
        else if (mp[i] > i) {

            // Update cntMinRem
            cntMinRem += (mp[i] - i);
        }
    }

    return cntMinRem;
}

// Driver Code
int main()
{

    int arr[] = { 2, 4, 1, 4, 2 };

    int N = sizeof(arr) / sizeof(arr[0]);

    cout << min_elements(arr, N);
    return 0;
}

Java

// Java program to implement
// the above approach
import java.util.*;

class GFG{

// Function to find the minimum count of
// elements required to be removed such
// that frequency of arr[i] equal to arr[i]
public static int min_elements(int arr[], int N)
{

    // Stores frequency of each
    // element of the array
    Map<Integer,
        Integer> mp = new HashMap<Integer,
                                  Integer>();

    // Traverse the array
    for(int i = 0; i < N; i++)
    {

        // Update frequency
        // of arr[i]
        mp.put(arr[i],
               mp.getOrDefault(arr[i], 0) + 1);
    }

    // Stores minimum count of removals
    int cntMinRem = 0;

    // Traverse the map
    for(int key : mp.keySet())
    {

        // Stores key value
        // of the map
        int i = key;
        int val = mp.get(i);

        // If frequency of i is
        // less than i
        if (val < i)
        {

            // Update cntMinRem
            cntMinRem += val;
        }

        // If frequency of i is
        // greater than i
        else if (val > i)
        {

            // Update cntMinRem
            cntMinRem += (val - i);
        }
    }
    return cntMinRem;
}

// Driver Code
public static void main(String[] args)
{
    int arr[] = { 2, 4, 1, 4, 2 };

    System.out.println(min_elements(
        arr, arr.length));
}
}

// This code is contributed by grand_master

Python3

# Python3 program to implement
# the above approach

# Function to find the minimum count of
# elements required to be removed such
# that frequency of arr[i] equal to arr[i]
def min_elements(arr, N) :

    # Stores frequency of each
    # element of the array
    mp = {};

    # Traverse the array
    for i in range(N) :

        # Update frequency
        # of arr[i]
        if arr[i] in mp :
            mp[arr[i]] += 1;
        else :
            mp[arr[i]] = 1;

    # Stores minimum count of removals
    cntMinRem = 0;

    # Traverse the map
    for it in mp :

        # Stores key value
        # of the map
        i = it;

        # If frequency of i is
        # less than i
        if (mp[i] < i) :

            # Update cntMinRem
            cntMinRem += mp[i];

        # If frequency of i is
        # greater than i
        elif (mp[i] > i) :

            # Update cntMinRem
            cntMinRem += (mp[i] - i);

    return cntMinRem;

# Driver Code
if __name__ == "__main__" :

    arr = [ 2, 4, 1, 4, 2 ];
    N = len(arr);
    print(min_elements(arr, N));

    # This code is contributed by AnkThon

C#

// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
class GFG
{

    // Function to find the minimum count of
    // elements required to be removed such
    // that frequency of arr[i] equal to arr[i]
    static int min_elements(int[] arr, int N)
    {

        // Stores frequency of each
        // element of the array
        Dictionary<int, int> mp = new Dictionary<int, int>();

        // Traverse the array
        for (int i = 0; i < N; i++)
        {

            // Update frequency
            // of arr[i]
            if(mp.ContainsKey(arr[i]))
            {
                mp[arr[i]]++;
            }
            else
            {
                mp[arr[i]] = 1;
            }
        }

        // Stores minimum count of removals
        int cntMinRem = 0;

        // Traverse the map
        foreach (KeyValuePair<int, int> it in mp)
        {

            // Stores key value
            // of the map
            int i = it.Key;

            // If frequency of i is
            // less than i
            if (mp[i] < i)
            {

                // Update cntMinRem
                cntMinRem += mp[i];
            }

            // If frequency of i is
            // greater than i
            else if (mp[i] > i)
            {

                // Update cntMinRem
                cntMinRem += (mp[i] - i);
            }
        }
        return cntMinRem;
    }

  // Driver code
  static void Main()
  {
    int[] arr = { 2, 4, 1, 4, 2 };
    int N = arr.Length;
    Console.Write(min_elements(arr, N));
  }
}

// This code is contributed by divyesh072019

Javascript

<script>

// Javascript program to implement
// the above approach

// Function to find the minimum count of
// elements required to be removed such
// that frequency of arr[i] equal to arr[i]
function min_elements(arr, N)
{
    // Stores frequency of each
    // element of the array
    var mp = new Map();

    // Traverse the array
    for (var i = 0; i < N; i++) {

        // Update frequency
        // of arr[i]
        if(mp.has(arr[i]))
        {
            mp.set(arr[i], mp.get(arr[i])+1);
        }
        else
        {
            mp.set(arr[i], 1);
        }
    }

    // Stores minimum count of removals
    var cntMinRem = 0;

    // Traverse the map
    mp.forEach((value, key) => {

        // Stores key value
        // of the map
        var i = key;

        // If frequency of i is
        // less than i
        if (mp.get(i) < i) {

            // Update cntMinRem
            cntMinRem += mp.get(i);
        }

        // If frequency of i is
        // greater than i
        else if (mp.get(i) > i) {

            // Update cntMinRem
            cntMinRem += (mp.get(i) - i);
        }
    });

    return cntMinRem;
}

// Driver Code
var arr = [2, 4, 1, 4, 2];
var N = arr.length;
document.write( min_elements(arr, N));

</script>

Output:

2

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