Skip to content
Related Articles
Get the best out of our app
GFG App
Open App
geeksforgeeks
Browser
Continue

Related Articles

Minimize the maximum frequency of Array elements by replacing them only once

Improve Article
Save Article
Like Article
author
aarohirai2616
contributor
49 published articles
Improve Article
Save Article
Like Article

Given an array A[] of length N, the task is to minimize the maximum frequency of any array element by performing the following operation only once:

  • Choose any random set (say S) of indices i (0 ≤ i ≤ N-1) of the array such that every element of S is the same and 
  • Replace every element of that index with any other number.

Examples:

Input: A[] = {1 ,4 ,4 ,1 ,4 , 4} 
Output: 2
Explanation: Choose index i = {1, 2} and perform the operation 
{ 1, 4, 4, 1, 4, 4 }→ { 1, 5, 5, 1, 4, 4 }. 
The highest frequency is of element 4, 5 and 1 which is 2. 
This is the minimum possible value of highest frequency of an element.

Input: A[] = {5 ,5 ,5 ,5 ,5 } 
Output: 3

Approach: The problem can be solved based on the following observation: 

  • Let N be the element with the maximum frequency in A[] and M be the element with the second maximum frequency in A[]. It is possible that M does not exist.
  • If M exist then maximum frequency = freqN. 
    • Indices such that A[i] = N, should be chosen because the final value of freqN should be minimized and it is always better to replace with number(num) such that num ≠ M. Only a maximum of ⌊ freqN/2⌋ elements should be replaced because if we replace more, then num becomes the new element with the maximum frequency
    • Hence, it is optimal to replace ⌊ freqN/2⌋  occurrences of N to some num ≠ M.Now, freqN – ⌊ freqN/2⌋ is the final frequency of N and freqM  is the final frequency of M. 
    • The maximum among these two i.e. Max( freqN – ⌊ freqN/2⌋, freqM ) has to be the answer because the frequency of num = ⌊freqN/2⌋ ≤( freqN – ⌊ freqN/2⌋) = frequency of N .
  • If M does not exist it means freqM = 0 . So , the answer is freqN – ⌊ freqN/2⌋.

Follow the below steps to implement the above idea:

  • Find the frequency of the most frequent and the second most frequent element.
  • Compare those frequencies.
    • Based on the frequency, follow the above conditions to find the minimized value of maximum frequency.

Below is the implementation of the above approach.

C++

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

// Function to minimize frequency of
// most frequent element
int minFreq(int arr[], int n)
{

    int b[n];
    for (int i = 0; i < n; i++) {
        b[i] = 0;
    }
    unordered_map<int, int> mp;
    for (int i = 0; i < n; i++) {
        if (mp.count(arr[i]) < 0) {
            mp[arr[i]] = 1;
        }
        else {
            mp[arr[i]]++;
        }
    }

    for (int i = 0; i < n; i++) {
        if (mp[arr[i]] != -1) {

            // Count frequency of each element
            b[i] = mp[arr[i]];
            mp[arr[i]] = -1;
        }
    }

    // Last index value is maximum
    // frequency of any element
    sort(b, b + n);
    if (b[n - 1] % 2 == 0) {
        b[n - 1] = b[n - 1] / 2;
    }
    else {
        b[n - 1] = (b[n - 1] + 1) / 2;
    }

    // Last index value is possible
    // minimum frequency of
    // most frequent element
    sort(b, b + n);
    return b[n - 1];
}

int main()
{

    int A[] = { 1, 4, 4, 1, 4, 4 };
    int N = sizeof(A) / sizeof(A[0]);

    // Function call
    cout << (minFreq(A, N));
    return 0;
}

// This code is contributed by akashish__

Java

// Java code to implement the approach
import java.io.*;
import java.util.*;

class GFG {

    // Function to minimize frequency of 
    // most frequent element
    public static int minFreq(int arr[], int n)
    {

        int[] b = new int[n];
        Map<Integer, Integer> mp = new HashMap<>();
        for (int i = 0; i < n; i++) {
            mp.put(arr[i], mp.get(arr[i]) == null
                               ? 1
                               : mp.get(arr[i]) + 1);
        }

        for (int i = 0; i < n; i++) {
            if (mp.get(arr[i]) != -1) {
                
                // Count frequency of each element
                b[i] = mp.get(arr[i]);
                mp.put(arr[i], -1);
            }
        }

        // Last index value is maximum
        // frequency of any element
        Arrays.sort(b);
        if (b[n - 1] % 2 == 0) {
            b[n - 1] = b[n - 1] / 2;
        }
        else {
            b[n - 1] = (b[n - 1] + 1) / 2;
        }
        
        // Last index value is possible
        // minimum frequency of 
        // most frequent element
        Arrays.sort(b);
        return b[n - 1];
    }
    
      // Driver Code
    public static void main(String[] args)
    {
        int A[] = { 1, 4, 4, 1, 4, 4 };
        int N = A.length;

        // Function call
        System.out.println(minFreq(A, N));
    }
}

Python3

# Python3 code to implement the above approach

# Function to minimize frequency of 
# most frequent element
def minFreq(arr, n) :
    
    b = [0] * n;
    
    mp = dict.fromkeys(arr, 0);
    
    for i in range(n) :
        
        if arr[i] in mp :
            mp[arr[i]] +=1;
            
        else :
            mp[arr[i]] = 1;
          
    for i in range(n) :
        
        if (mp[arr[i]] != -1) :
            # Count frequency of each element
            b[i] = mp[arr[i]];
            mp[arr[i]] = -1;

    # Last index value is maximum
    # frequency of any element
    b.sort()
        
    if (b[n - 1] % 2 == 0) :
        b[n - 1] = b[n - 1] // 2;
    else :
        b[n - 1] = (b[n - 1] + 1) // 2;
        
    # Last index value is possible
    # minimum frequency of 
    # most frequent element
    b.sort();    
    return b[n - 1];

if __name__ == "__main__" :
    
    A = [ 1, 4, 4, 1, 4, 4 ];
    N = len(A);

    # Function call
    print(minFreq(A, N));
   
    # This code is contributed by AnkThon

C#

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

  // Function to minimize frequency of
  // most frequent element
  public static int minFreq(int[] arr, int n)
  {

    int[] b = new int[n];
    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);
    }

    for (int i = 0; i < n; i++) {
      if (mp[arr[i]] != -1) {

        // Count frequency of each element
        b[i] = mp[arr[i]];
        mp[arr[i]] = -1;
      }
    }

    // Last index value is maximum
    // frequency of any element
    Array.Sort(b);
    if (b[n - 1] % 2 == 0) {
      b[n - 1] = b[n - 1] / 2;
    }
    else {
      b[n - 1] = (b[n - 1] + 1) / 2;
    }

    // Last index value is possible
    // minimum frequency of
    // most frequent element
    Array.Sort(b);
    return b[n - 1];
  }

  // Driver Code
  public static void Main(String[] args)
  {
    int[] A = { 1, 4, 4, 1, 4, 4 };
    int N = A.Length;

    // Function call
    Console.WriteLine(minFreq(A, N));
  }
}

// This code is contributed by ukasp.

Javascript

<script>
// Javascript code to implement the approach

// Function to minimize frequency of 
// most frequent element
function minFreq(arr, n) {

    let b = new Array(n).fill(0);
    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)
        }
    }

    for (let i = 0; i < n; i++) {
        if (mp.get(arr[i]) != -1) {

            // Count frequency of each element
            b[i] = mp.get(arr[i]);
            mp.set(arr[i], -1);
        }
    }

    // Last index value is maximum
    // frequency of any element
    b.sort((a, b) => a - b);
    if (b[n - 1] % 2 == 0) {
        b[n - 1] = Math.floor(b[n - 1] / 2);
    }
    else {
        b[n - 1] = Math.floor((b[n - 1] + 1) / 2);
    }

    // Last index value is possible
    // minimum frequency of 
    // most frequent element
    b.sort((a, b) => a - b);
    return b[n - 1];
}

// Driver Code

let A = [1, 4, 4, 1, 4, 4];
let N = A.length;

// Function call
document.write(minFreq(A, N));

// This code is contributed by saurabh_jaiswal.
</script>
Output

2

Time Complexity: O(N * logN) //the inbuilt sort function takes N log N time to complete all operations, hence the overall time taken by the algorithm is N log N
Auxiliary Space: O(N) // an extra array is used and in the worst case all elements will be stored inside it the hence algorithm takes up linear space


My Personal Notes arrow_drop_up
Last Updated : 21 Dec, 2022
Like Article
Save Article
Similar Reads
1. Minimize steps to make two integers equal by incrementing them or doing bitwise OR of them
2. Minimize remaining array element by removing pairs and replacing them by their absolute difference
3. Minimize remaining array element by removing pairs and replacing them with their average
4. Count of elements in first Array greater than second Array with each element considered only once
5. Count ways to split array into two equal sum subarrays by replacing each array element to 0 once
6. Elements that occurred only once in the array
7. Count elements in Array appearing only once and don't have its consecutive next and previous present
8. Minimize steps to make all Array elements equal by cyclically shifting a segment or replacing prefix by maximum
9. Sum of elements in 1st array such that number of elements less than or equal to them in 2nd array is maximum
10. Minimize Array sum by replacing elements such that Relation among adjacent elements in maintained
Related Tutorials
1. Learn Data Structures with Javascript | DSA Tutorial
2. Introduction to Max-Heap – Data Structure and Algorithm Tutorials
3. Introduction to Set – Data Structure and Algorithm Tutorials
4. Introduction to Map – Data Structure and Algorithm Tutorials
5. What is Dijkstra’s Algorithm? | Introduction to Dijkstra's Shortest Path Algorithm
Previous
Check if given two Arrays are equal (using Map)
Next
Maximize MEX by adding or subtracting K from Array elements
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
aarohirai2616
@aarohirai2616
Vote for difficulty
Current difficulty : Expert
Improved By :
Article Tags :
Practice Tags :
Report Issue
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox