Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Maximum frequency of any array element possible by exactly K increments

  • Difficulty Level : Hard
  • 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:

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 <bits/stdc++.h>
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[0]);
    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




<script>
 
// Javascript program for the above approach
 
// Function to find the highest frequency
// of any array element possible by
// exactly K increment operations
function findMostFrequent(arr, N, K) {
    let start = 0, end = 0;
 
    // Sort the given array
    arr.sort((a, b) => a - b);
 
    // Stores the maximum frequency
    // and the sum of sliding window
    let mostFreq = Number.MIN_SAFE_INTEGER, 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
    let 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) {
            document.write(N + "<br>");
        }
 
        // Otherwise first make every
        // element equal then increment
        // remaining K to one element
        else {
            document.write(N - 1 + "<br>");
        }
 
        return;
    }
 
    // Print the answer
    document.write(mostFreq + "<br>");
}
 
// Driver Code
let arr = [4, 3, 4];
let K = 5;
let N = arr.length
findMostFrequent(arr, N, K);
 
// This code is contributed by _saurabh_jaiswal.
</script>


Output: 

2

 

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


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!