Minimum removal of K equal elements required to empty an array

Given an array arr[] consisting of N integers, the task is to count the minimum number of times at most K equal elements are required to be removed to make the array empty.

Examples:

Input: arr[] = {1, 3, 1, 1, 3}, K = 2
Output: 3
Explanation: 
Step 1: Remove at most 2 1s from the array. The modified array is {1, 3, 3}. 
Step 2: Remove at most 2 3s from the array. The modified array is {1}. 
Step 3: Remove at most 2 1s from the array. The modified array is {}. 
After 3 steps, the array becomes empty. 
Therefore, the minimum number of steps required is 3. 
 

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

Naive Approach: The simplest approach is to traverse the array and count the frequency of every array element and then, divide the frequency of every element by K and add it to count. Increment count if the frequency of the array element is not divisible by K. After completing the above steps, print the value of count as the result.
Time Complexity: O(N²)
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized by Hashing to store the frequency of each array element and then count the minimum number of operations required. Follow the steps below to solve the problem:

• Initialize a variable, say, count, that stores the minimum number of steps required.
• Initialize Hashmap that stores the frequency of each element in the array.
• Traverse the array arr[] and store the frequencies of each element in the Hashmap.
• Traverse the Hashmap and add the value of frequency of each element, divided by K, to the variable count. If the frequency of the current array element is not divisible by K, then increment the count by 1.
• After completing the above steps, print count as the required minimum number of steps required to make the array empty.

Below is the implementation of the above approach:

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to count the minimum
// number of steps required to empty
// given array by removing at most K
// equal array elements in each operation
void minSteps(int arr[], int N, int K)
{
  
    // Stores the minimum number of
    // steps required to empty the array
    int count = 0;

    // Stores the occurrence
    // of each array element
    map<int, int> cntFreq;
    for (int i = 0; i < N; i++)
    {

        // Update the frequency
        cntFreq[arr[i]]++;
    }

    // Traverse the Hashmap
    for (auto i : cntFreq) 
    {

        // Check if the frequency
        // is divisible by K or not
        if (i.first % K == 0)
            count += i.second / K;

        // Otherwise
        else
            count += (i.second / K) + 1;
    }

    // Print the count of
    // minimum steps required
    cout << (count);
}

// Driver Code
int main()
{

    int arr[] = { 4, 4, 7, 3, 1, 
                 1, 2, 1, 7, 3 };
    int N = sizeof(arr) / sizeof(arr[0]);
    int K = 5;
    minSteps(arr, N, K);
    return 0;
}

// This code is contributed by Dharanendra L V.

// Java program for the above approach

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

class GFG {

    // Function to count the minimum
    // number of steps required to empty
    // given array by removing at most K
    // equal array elements in each operation
    public static void minSteps(
        int[] arr, int N, int K)
    {
        // Stores the minimum number of
        // steps required to empty the array
        int count = 0;

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

        for (int i = 0; i < N; i++) {

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

        // Traverse the Hashmap
        for (Integer i : cntFreq.keySet()) {

            // Check if the frequency
            // is divisible by K or not
            if (cntFreq.get(i) % K == 0)
                count += cntFreq.get(i)
                         / K;

            // Otherwise
            else
                count += (cntFreq.get(i)
                          / K)
                         + 1;
        }

        // Print the count of
        // minimum steps required
        System.out.print(count);
    }

    // Driver Code
    public static void main(String[] args)
    {
        int arr[] = { 4, 4, 7, 3, 1,
                      1, 2, 1, 7, 3 };
        int N = arr.length;
        int K = 5;

        minSteps(arr, N, K);
    }
}

# Python3 program for the above approach

# Function to count the minimum
# number of steps required to empty
# given array by removing at most K
# equal array elements in each operation
def minSteps(arr, N, K) :
   
    # Stores the minimum number of
    # steps required to empty the array
    count = 0
 
    # Stores the occurrence
    # of each array element
    cntFreq = {}
    for i in range(N) :
 
        # Update the frequency
        if arr[i] in cntFreq :
            cntFreq[arr[i]] += 1
        else :
            cntFreq[arr[i]] = 1
 
    # Traverse the Hashmap
    for i in cntFreq :
 
        # Check if the frequency
        # is divisible by K or not
        if (i % K == 0) :
            count += cntFreq[i] // K
 
        # Otherwise
        else :
            count += (cntFreq[i] // K) + 1
 
    # Print the count of
    # minimum steps required
    print(count)
    
arr = [ 4, 4, 7, 3, 1, 1, 2, 1, 7, 3 ]
N = len(arr)
K = 5
minSteps(arr, N, K)

# This code is contributed by divyeshabadiya07.

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

    // Function to count the minimum
    // number of steps required to empty
    // given array by removing at most K
    // equal array elements in each operation
    public static void minSteps(
        int[] arr, int N, int K)
    {
        // Stores the minimum number of
        // steps required to empty the array
        int count = 0;

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

        for (int i = 0; i < N; i++) {

            // Update the frequency
            if(cntFreq.ContainsKey(arr[i]))
                cntFreq[arr[i]] = cntFreq[arr[i]]+1;
            else
                
            cntFreq.Add(arr[i],1);
        }

        // Traverse the Hashmap
        foreach (int i in cntFreq.Keys) {

            // Check if the frequency
            // is divisible by K or not
            if (cntFreq[i] % K == 0)
                count += cntFreq[i]
                         / K;

            // Otherwise
            else
                count += (cntFreq[i]
                          / K)
                         + 1;
        }

        // Print the count of
        // minimum steps required
        Console.Write(count);
    }

    // Driver Code
    public static void Main(String[] args)
    {
        int []arr = { 4, 4, 7, 3, 1,
                      1, 2, 1, 7, 3 };
        int N = arr.Length;
        int K = 5;

        minSteps(arr, N, K);
    }
}

// This code is contributed by shikhasingrajput 

<script>
      // JavaScript program for the above approach
      // Function to count the minimum
      // number of steps required to empty
      // given array by removing at most K
      // equal array elements in each operation
      function minSteps(arr, N, K) {
        // Stores the minimum number of
        // steps required to empty the array
        var count = 0;

        // Stores the occurrence
        // of each array element
        var cntFreq = {};

        for (var i = 0; i < N; i++) {
          // Update the frequency
          if (cntFreq.hasOwnProperty(arr[i])) 
              cntFreq[arr[i]] += 1;
          else 
              cntFreq[arr[i]] = 1;
        }

        // Traverse the Hashmap
        for (const [key, value] of Object.entries(cntFreq)) {
          // Check if the frequency
          // is divisible by K or not
          if (key % K == 0) 
              count += parseInt(cntFreq[key] / K);
          // Otherwise
          else 
              count += parseInt(cntFreq[key] / K) + 1;
        }

        // Print the count of
        // minimum steps required
        document.write(count);
      }

      // Driver Code
      var arr = [4, 4, 7, 3, 1, 1, 2, 1, 7, 3];
      var N = arr.length;
      var K = 5;

      minSteps(arr, N, K);
</script>

5

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