使每个数组元素的频率等于其值所需的最小移除量

给定大小为N的数组arr [] ，任务是找到需要删除的最小数组元素数，以使每个数组元素的频率等于其值

例子：

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

方法：可以使用贪婪技术解决问题。请按照以下步骤解决问题：

• 初始化一个映射，例如mp，以存储数组中每个不同元素的频率。
• 遍历数组并存储数组中每个不同元素的频率。
• 初始化一个变量cntMinRem，以存储需要删除的最小数组元素数，以使arr [i]的频率等于arr [i] 。
• 使用地图的键值作为i遍历地图，并检查以下条件：
  • 如果mp [i] ，则更新cntMinRem + = mp [i]的值。
  • 如果mp [i]> i ，则更新cntMinRem + =(mp [i] – i)的值。
• 最后，打印cntMinRem的值。

下面是上述方法的实现：

C++14

// C++ program to implement
// the above approach
 
#include 
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 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 mp = new HashMap();
 
    // 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 mp = new Dictionary(); 
      
        // 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 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

输出：

2

时间复杂度： O(N)
辅助空间： O(N)