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

• Difficulty Level : Expert
• Last Updated : 26 Sep, 2022

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 freq 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 ` `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 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);`   `        ``// 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 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

 ``

Output

`2`

Time Complexity: O(N * logN)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :