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

// 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

import java.util.*;

public class Main {
    // Declare a list to store prefix sum values
    static List<Long> preSum = new ArrayList<>();

    // Define the helper function that takes in a list of
    // integers nums, an integer k, and an integer index as
    // input
    static int helper(List<Integer> nums, int k, int index)
    {
        // Initialize variables low, high, and res to store
        // the lower index, higher index, and the result
        // index
        int low = 0;
        int high = index;
        int res = index;
        // Perform binary search to find the maximum
        // frequency of the current element by varying the
        // element to its left
        while (low <= high) {
            int mid = low + (high - low) / 2;
            // Calculate the sum of the elements from mid to
            // index
            long s
                = preSum.get(index + 1) - preSum.get(mid);
            // Check if the sum can be increased by at most
            // k by replacing the elements from mid to index
            // with the current element nums[index]
            if (s + k >= (long)(index - mid + 1)
                             * nums.get(index)) {
                // If yes, update the result to mid and
                // search for a better solution to the left
                // of mid
                res = mid;
                high = mid - 1;
            }
            else {
                // If no, search for a better solution to
                // the right of mid
                low = mid + 1;
            }
        }
        // Return the frequency of the current element
        return index - res + 1;
    }

    // Define the maxFrequency function that takes in a list
    // of integers nums and an integer k as input
    static int maxFrequency(List<Integer> nums, int k)
    {
        // Sort the input list in non-decreasing order
        Collections.sort(nums);
        // Get the size of the input list
        int n = nums.size();
        // Resize the prefix sum list to size n+1
        preSum = new ArrayList<>(
            Collections.nCopies(n + 1, 0L));
        // Calculate the prefix sum values and store them in
        // the prefix sum list
        for (int i = 0; i < n; i++) {
            preSum.set(i + 1, preSum.get(i) + nums.get(i));
        }
        // Initialize a variable ans to store the maximum
        // frequency
        int ans = 0;
        // Iterate over each element of the input list
        for (int i = 0; i < n; i++) {
            // Update the maximum frequency by taking the
            // maximum of the current maximum frequency and
            // the frequency of the current element
            ans = Math.max(ans, helper(nums, k, i));
        }
        // Return the maximum frequency
        return ans;
    }

    // Driver code
    public static void main(String[] args)
    {
        List<Integer> arr = Arrays.asList(1, 4, 8, 13);
        int K = 5;
        System.out.println(
            "Frequency of the Most Frequent Element : "
            + maxFrequency(arr, K));
    }
}
//this code is contributed by Ravi Singh