# Apply Operations To Maximize Frequency Score

## Problem Statement

We are given a 0-indexed integer array nums and an integer k.

We can perform the following operation on the array at most k times:

Choose any index i from the array and increase or decrease nums[i] by 1.

The score of the final array is the frequency of the most frequent element in the array.

Return the maximum score you can achieve.

The frequency of an element is the number of occurrences of that element in the array.

## Java Implementation

### Java Approach Using Prefix Sum

Output:

Code Explanation

• The Java code solves the problem of finding the maximum score achievable within a given maximum number of operations (k). It uses a binary search approach on the potential scores. For each score, it checks if it's possible to achieve within the allowed operations by sliding a window through the sorted array.
• The is_possible method efficiently calculates the number of operations needed to convert subarrays to the target score.
• The main function performs a binary search on potential scores, updating the result whenever a valid score is found. The algorithm utilizes prefix sums for quick subarray sum calculations, optimizing performance.

Time Complexity:

• The algorithm has a time complexity of O(nlog n), where 'n' represents the number of elements in the input array. This complexity is due to the binary search operation on the possible scores.

Space Complexity:

• The space complexity is O(n) because of the prefix sum array width that needs to be added for efficient partial sum calculations. It is linear in terms of the size of the input array.

### Java Approach Using Sliding Window

Output:

Code Explanation

• The code implements the maxFrequencyScore function to find the maximum frequency score of a sorted array using a sliding window approach. It initializes two pointers, i and j, representing the window's start and end.
• The variable cur maintains the current score within the window. The program iterates through the sorted array, adjusting the window to minimize the score. The inner loop shifts the window until the score (cur) becomes less than or equal to the given limit k. The maximum length of the window (j - i + 1) during this process represents the maximum frequency score achieved.

Time Complexity:

• The time complexity of this implementation is O(n log n). It has a complexity of O(n log n) where 'n' denotes the number of elements in array A. This complexity is only present due to a sorting procedure.

Space Complexity:

• O(1) is used by the algorithm for the space complexity because it needs constant space memory no matter what size of the input is.

### Java Approach Using Sliding Window With Advanced Version

Output:

Code Explanation:

• The code implements a sliding window approach to find the maximum length of a subarray with a sum less than or equal to a given value, k. It starts with a sorted array, adjusting the sum based on the sliding window.
• The variable "i" represents the starting index of the subarray, and "j" iterates through the array. If the adjusted sum exceeds k, the window contracts by incrementing "i." The result is the maximum length of a subarray satisfying the condition.

Time Complexity:

• The code's time complexity is O(n log n), mostly because of sorting. The time complexity for the sliding window operation is considered to be linear.

Space Complexity:

• The space complexity is O(1) due to the fact that this algorithm employs a constant additional space, regardless the value of the data itself. Sorting is located here, which reduces effective notation to a few entries for block transform sliding window operation.