# Maximum frequency of any array element possible by exactly K increments

• Difficulty Level : Medium
• Last Updated : 03 Aug, 2021

Given an array arr[] consisting of N positive integers and an integer K, the task is to find the highest frequency of any array element after performing exactly K increments.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {1, 3, 2, 2}, K = 2
Output: 3
Explanation:
Below are the operations performed:

1. Add 1 to the element at index 2(= 2), then the array modifies to {1, 3, 3, 2}.
2. Add 1 to the element at index 3(= 2), then the array modifies to {1, 3, 3, 3}.

After the above steps, the maximum frequency of an array element is 3.

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

Approach: The given problem can be solved by using the Sliding Window Technique and Sorting. Follow the steps below to solve this problem:

• Initialize the variables say start, end, sum as 0, and mostFreq as INT_MIN.
• Sort the array arr[] in increasing order.
• Iterate over the range [0, N – 1] using the variable end and perform the following steps:
• Increment the value of sum by the value arr[end].
• While the value of (sum + K) is less than the value of (arr[end] * (end – start+ 1)), then decrement the value of the sum by arr[start] and increment the value of start by 1.
• Update the value of mostFreq to the maximum of mostFreq and (end – start + 1).
• Initialize a variable, say reqSum as the value of (arr[N-1] * N – sum) that stores the resultant sum to make all the array elements equal.
• If the value of mostFreq is N and the value of K is greater than reqSum, then decrement the value of K by reqSum.
• If the value of K is a multiple of N, then print N. Otherwise, print the value of (N – 1).
• After completing the above steps, print the value of mostFreq as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the highest frequency``// of any array element possible by``// exactly K increment operations``void` `findMostFrequent(``int` `arr[], ``int` `N,``                      ``int` `K)``{``    ``int` `start = 0, end = 0;` `    ``// Sort the given array``    ``sort(arr, arr + N);` `    ``// Stores the maximum frequency``    ``// and the sum of sliding window``    ``int` `mostFreq = INT_MIN, sum = 0;` `    ``// Traverse the array arr[]``    ``for` `(end = 0; end < N; end++) {` `        ``// Add the current element``        ``// to the window``        ``sum = sum + arr[end];` `        ``// Decreasing the window size``        ``while` `(sum + K < arr[end] * (end - start + 1)) {` `            ``// Update the value of sum``            ``// by subtracting arr[start]``            ``sum = sum - arr[start];` `            ``// Increment the value``            ``// of the start``            ``start++;``        ``}` `        ``// Update maximum window size``        ``mostFreq = max(mostFreq,``                       ``end - start + 1);``    ``}` `    ``// Stores the required sum to``    ``// make all elements of arr[] equal``    ``int` `reqSum = arr[N - 1] * N - sum;` `    ``// If result from at most K increments``    ``// is N and K is greater than reqSum``    ``if` `(mostFreq == N && reqSum < K) {` `        ``// Decrement the value of K``        ``// by reqSum``        ``K = K - reqSum;` `        ``// If K is mutilpe of N then``        ``// increment K/N times to``        ``// every element``        ``if` `(K % N == 0) {``            ``cout << N << endl;``        ``}` `        ``// Otherwise first make every``        ``// element equal then increment``        ``// remaining K to one element``        ``else` `{``            ``cout << N - 1 << endl;``        ``}` `        ``return``;``    ``}` `    ``// Print the answer``    ``cout << mostFreq << endl;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 4, 3, 4 };``    ``int` `K = 5;``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``findMostFrequent(arr, N, K);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach` `import` `java.util.*;` `class` `GFG {` `// Function to find the highest frequency``// of any array element possible by``// exactly K increment operations``static` `void` `findMostFrequent(``int` `arr[], ``int` `N,``                      ``int` `K)``{``    ``int` `start = ``0``, end = ``0``;` `    ``// Sort the given array``    ``Arrays.sort(arr);` `    ``// Stores the maximum frequency``    ``// and the sum of sliding window``    ``int` `mostFreq = Integer.MIN_VALUE, sum = ``0``;` `    ``// Traverse the array arr[]``    ``for` `(end = ``0``; end < N; end++) {` `        ``// Add the current element``        ``// to the window``        ``sum = sum + arr[end];` `        ``// Decreasing the window size``        ``while` `(sum + K < arr[end] * (end - start + ``1``)) {` `            ``// Update the value of sum``            ``// by subtracting arr[start]``            ``sum = sum - arr[start];` `            ``// Increment the value``            ``// of the start``            ``start++;``        ``}` `        ``// Update maximum window size``        ``mostFreq = Math.max(mostFreq,``                       ``end - start + ``1``);``    ``}` `    ``// Stores the required sum to``    ``// make all elements of arr[] equal``    ``int` `reqSum = arr[N - ``1``] * N - sum;` `    ``// If result from at most K increments``    ``// is N and K is greater than reqSum``    ``if` `(mostFreq == N && reqSum < K) {` `        ``// Decrement the value of K``        ``// by reqSum``        ``K = K - reqSum;` `        ``// If K is mutilpe of N then``        ``// increment K/N times to``        ``// every element``        ``if` `(K % N == ``0``) {``            ``System.out.println(N);``        ``}` `        ``// Otherwise first make every``        ``// element equal then increment``        ``// remaining K to one element``        ``else` `{``            ``System.out.println(N - ``1``);``        ``}` `        ``return``;``    ``}` `    ``// Print the answer``    ``System.out.println( mostFreq);``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``    ``int` `arr[] = { ``4``, ``3``, ``4` `};``    ``int` `K = ``5``;``    ``int` `N = arr.length;``    ``findMostFrequent(arr, N, K);``    ``}``}` `// This code is contributed by target_2.`

## Python3

 `# Python program for the above approach` `# Function to find the highest frequency``# of any array element possible by``# exactly K increment operations``def` `findMostFrequent( arr,  N, K):``    ``start ``=` `0``    ``end ``=` `0``    ` `    ``# Sort the given array``    ``arr.sort()``    ` `    ``# Stores the maximum frequency``    ``# and the sum of sliding window``    ``mostFreq ``=` `-``2``*``*``31``    ``sum` `=` `0``    ` `    ``# Traverse the array arr[]``    ``for` `end ``in` `range``(N):``        ` `        ``# Add the current element``        ``# to the window``        ``sum` `=` `sum` `+` `arr[end]``        ` `        ``# Decreasing the window size``        ``while` `(``sum` `+` `K < arr[end] ``*` `(end ``-` `start ``+` `1``)):``            ` `            ``# Update the value of sum``            ``# by subtracting arr[start]``            ``sum` `=` `sum` `-` `arr[start]``            ` `            ``# Increment the value``            ``# of the start``            ``start ``+``=` `1``            ` `        ``# Update maximum window size``        ``mostFreq ``=` `max``(mostFreq, end ``-` `start ``+` `1``)``        ` `    ``# Stores the required sum to``    ``# make all elements of arr[] equal``    ``reqSum ``=` `arr[N ``-` `1``] ``*` `N ``-` `sum``    ` `    ``# If result from at most K increments``    ``# is N and K is greater than reqSum``    ``if` `(mostFreq ``=``=` `N ``and` `reqSum < K):``        ` `        ``# Decrement the value of K``        ``# by reqSum``        ``K ``=` `K ``-` `reqSum``        ` `        ``# If K is mutilpe of N then``        ``# increment K/N times to``        ``# every element``        ``if` `(K ``%` `N ``=``=` `0``):``            ``print``(N)``            ` `        ``# Otherwise first make every``        ``# element equal then increment``        ``# remaining K to one element``        ``else``:``            ``print``(N ``-` `1``)``        ``return``    ``# Print the answer``    ``print``(mostFreq)` `# Driver Code``arr ``=` `[``4``, ``3``, ``4``]``K ``=` `5``N ``=` `len``(arr)``findMostFrequent(arr, N, K)` `# This code is contributed by shubhamsingh10`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to find the highest frequency``// of any array element possible by``// exactly K increment operations``static` `void` `findMostFrequent(``int` `[]arr, ``int` `N,``                             ``int` `K)``{``    ``int` `start = 0, end = 0;` `    ``// Sort the given array``    ``Array.Sort(arr);` `    ``// Stores the maximum frequency``    ``// and the sum of sliding window``    ``int` `mostFreq = Int32.MinValue, sum = 0;` `    ``// Traverse the array arr[]``    ``for``(end = 0; end < N; end++)``    ``{``        ` `        ``// Add the current element``        ``// to the window``        ``sum = sum + arr[end];` `        ``// Decreasing the window size``        ``while` `(sum + K < arr[end] * (end - start + 1))``        ``{``            ` `            ``// Update the value of sum``            ``// by subtracting arr[start]``            ``sum = sum - arr[start];` `            ``// Increment the value``            ``// of the start``            ``start++;``        ``}` `        ``// Update maximum window size``        ``mostFreq = Math.Max(mostFreq,``                            ``end - start + 1);``    ``}` `    ``// Stores the required sum to``    ``// make all elements of arr[] equal``    ``int` `reqSum = arr[N - 1] * N - sum;` `    ``// If result from at most K increments``    ``// is N and K is greater than reqSum``    ``if` `(mostFreq == N && reqSum < K)``    ``{``        ` `        ``// Decrement the value of K``        ``// by reqSum``        ``K = K - reqSum;` `        ``// If K is mutilpe of N then``        ``// increment K/N times to``        ``// every element``        ``if` `(K % N == 0)``        ``{``            ``Console.Write(N);``        ``}` `        ``// Otherwise first make every``        ``// element equal then increment``        ``// remaining K to one element``        ``else``        ``{``            ``Console.Write(N - 1);``        ``}``        ``return``;``    ``}` `    ``// Print the answer``    ``Console.Write( mostFreq);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 4, 3, 4 };``    ``int` `K = 5;``    ``int` `N = arr.Length;``    ` `    ``findMostFrequent(arr, N, K);``}``}` `// This code is contributed by shivanisinghss2110`

## Javascript

 ``
Output:
`2`

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

My Personal Notes arrow_drop_up