Related Articles

# Maximum frequency of any array element possible by at most K increments

• Difficulty Level : Hard
• Last Updated : 13 Jul, 2021

Given an array arr[] of size N and an integer K, the task is to find the maximum possible frequency of any array element by at most K increments.

Examples:

Input: arr[] = {1, 4, 8, 13}, N = 4, K = 5
Output:
Explanation:
Incrementing arr twice modifies arr[] to {4, 4, 8, 13}. Maximum frequency = 2.
Incrementing arr four times modifies arr[] to {1, 8, 8, 13}. Maximum frequency = 2.
Incrementing arr five times modifies arr[] to {1, 4, 13, 13}. Maximum frequency = 2.
Therefore, the maximum possible frequency of any array element that can be obtained by at most 5 increments is 2.

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

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

• Sort the array arr[].
• Initialize variables sum = 0, start = 0 and resultant frequency res = 0.
• Traverse the array over the range of indices [0, N – 1] and perform the following steps:
• Increment sum by arr[end].
• Iterate a loop until the value of [(end – start + 1) * arr[end] – sum] is less than K and perform the following operatiosn:
• Decrement the value of sum by arr[start].
• Increment the value of start by 1.
• After completing the above steps, all the elements over the range [start, end] can be made equal by using at most K operations. Therefore, update the value of res as the maximum of res and (end – start + 1).
• Finally, print the value of res as frequency of most frequent element after performing Koperations.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the maximum possible``// frequency of a most frequent element``// after at most K increment operations``void` `maxFrequency(``int` `arr[], ``int` `N, ``int` `K)``{``    ``// Sort the input array``    ``sort(arr, arr + N);` `    ``int` `start = 0, end = 0;` `    ``// Stores the sum of sliding``    ``// window and the maximum possible``    ``// frequency of any array element``    ``int` `sum = 0, res = 0;` `    ``// Traverse the array``    ``for` `(end = 0; end < N; end++) {` `        ``// Add the current element``        ``// to the window``        ``sum += arr[end];` `        ``// Decrease the window size` `        ``// If it is not possible to make the``        ``// array elements in the window equal``        ``while` `((end - start + 1) * arr[end] - sum > K) {` `            ``// Update the value of sum``            ``sum -= arr[start];` `            ``// Increment the value of start``            ``start++;``        ``}` `        ``// Update the maximum possible frequency``        ``res = max(res, end - start + 1);``    ``}` `    ``// Print the frequency of``    ``// the most frequent array``    ``// element after K increments``    ``cout << res << endl;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, 4, 8, 13 };``    ``int` `N = 4;``    ``int` `K = 5;``    ``maxFrequency(arr, N, K);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.Arrays;` `class` `GFG{` `// Function to find the maximum possible``// frequency of a most frequent element``// after at most K increment operations``static` `void` `maxFrequency(``int` `arr[], ``int` `N, ``int` `K)``{``    ` `    ``// Sort the input array``    ``Arrays.sort(arr);` `    ``int` `start = ``0``, end = ``0``;` `    ``// Stores the sum of sliding``    ``// window and the maximum possible``    ``// frequency of any array element``    ``int` `sum = ``0``, res = ``0``;` `    ``// Traverse the array``    ``for``(end = ``0``; end < N; end++)``    ``{``        ` `        ``// Add the current element``        ``// to the window``        ``sum += arr[end];` `        ``// Decrease the window size` `        ``// If it is not possible to make the``        ``// array elements in the window equal``        ``while` `((end - start + ``1``) *``                   ``arr[end] - sum > K)``        ``{``            ` `            ``// Update the value of sum``            ``sum -= arr[start];` `            ``// Increment the value of start``            ``start++;``        ``}` `        ``// Update the maximum possible frequency``        ``res = Math.max(res, end - start + ``1``);``    ``}` `    ``// Print the frequency of``    ``// the most frequent array``    ``// element after K increments``    ``System.out.println(res);``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``1``, ``4``, ``8``, ``13` `};``    ``int` `N = ``4``;``    ``int` `K = ``5``;``    ` `    ``maxFrequency(arr, N, K);``}``}` `// This code is contributed by abhinavjain194`

## Python3

 `# Python3 program for the above approach` `# Function to find the maximum possible``# frequency of a most frequent element``# after at most K increment operations``def` `maxFrequency(arr, N, K):``    ` `    ``# Sort the input array``    ``arr.sort()` `    ``start ``=` `0``    ``end ``=` `0` `    ``# Stores the sum of sliding``    ``# window and the maximum possible``    ``# frequency of any array element``    ``sum` `=` `0``    ``res ``=` `0` `    ``# Traverse the array``    ``for` `end ``in` `range``(N):` `        ``# Add the current element``        ``# to the window``        ``sum` `+``=` `arr[end]` `        ``# Decrease the window size` `        ``# If it is not possible to make the``        ``# array elements in the window equal``        ``while` `((end ``-` `start ``+` `1``) ``*` `arr[end] ``-` `sum` `> K):` `            ``# Update the value of sum``            ``sum` `-``=` `arr[start]` `            ``# Increment the value of start``            ``start ``+``=` `1` `        ``# Update the maximum possible frequency``        ``res ``=` `max``(res, end ``-` `start ``+` `1``)` `    ``# Print the frequency of``    ``# the most frequent array``    ``# element after K increments``    ``print``(res)` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ ``1``, ``4``, ``8``, ``13` `]``    ``N ``=` `4``    ``K ``=` `5``    ` `    ``maxFrequency(arr, N, K)``    ` `# This code is contributed by ipg2016107`

## C#

 `// C# program for the above approach``using` `System;``        ` `class` `GFG{` `// Function to find the maximum possible``// frequency of a most frequent element``// after at most K increment operations``static` `void` `maxFrequency(``int``[] arr, ``int` `N, ``int` `K)``{``    ` `    ``// Sort the input array``    ``Array.Sort(arr);` `    ``int` `start = 0, end = 0;` `    ``// Stores the sum of sliding``    ``// window and the maximum possible``    ``// frequency of any array element``    ``int` `sum = 0, res = 0;` `    ``// Traverse the array``    ``for``(end = 0; end < N; end++)``    ``{``        ` `        ``// Add the current element``        ``// to the window``        ``sum += arr[end];` `        ``// Decrease the window size` `        ``// If it is not possible to make the``        ``// array elements in the window equal``        ``while` `((end - start + 1) *``           ``arr[end] - sum > K)``        ``{``            ` `            ``// Update the value of sum``            ``sum -= arr[start];` `            ``// Increment the value of start``            ``start++;``        ``}` `        ``// Update the maximum possible frequency``        ``res = Math.Max(res, end - start + 1);``    ``}` `    ``// Print the frequency of``    ``// the most frequent array``    ``// element after K increments``    ``Console.WriteLine(res);``}``    ` `// Driver Code``public` `static` `void` `Main()``{``    ``int``[] arr = { 1, 4, 8, 13 };``    ``int` `N = 4;``    ``int` `K = 5;``    ` `    ``maxFrequency(arr, N, K);``}``}` `// This code is contributed by code_hunt`

## Javascript

 ``
Output:
`2`

Time Complexity: O(NlogN)
Auxiliary Space: O(1)

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.

My Personal Notes arrow_drop_up