Apply Operations to Maximize Frequency Score

Apply Operations to Maximize Frequency Score - Problem

Array Binary Search Sliding Window Sorting Prefix Sum Hard

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

You 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.

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,2,6,1], k = 3

› Output: 3

💡 Note: We can make [1,2,6,1] → [2,2,2,1] using 3 operations: change first 1→2 (1 op), change 6→2 (4 ops), but that exceeds k=3. Better: make [1,1,2] all equal to 2 with cost (2-1)+(2-1)+(2-2)=2≤3, giving frequency 3.

Example 2 — All Elements Same

$ Input: nums = [3,9,6], k = 2

› Output: 1

💡 Note: To make any 2 elements equal: min cost is |3-6|=3 or |3-9|=6 or |6-9|=3, all > k=2. So we can only achieve frequency 1.

Example 3 — Large Budget

$ Input: nums = [1,1,2,2], k = 4

› Output: 4

💡 Note: We can make all elements equal to 2: change two 1s to 2s costs 2 operations total. All 4 elements become 2, so frequency = 4.

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
1 ≤ nums[i] ≤ 10⁹
0 ≤ k ≤ 2 × 10¹⁴

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Meta 6 M Microsoft 5

The key insight is to sort the array first, then use sliding window technique to efficiently find the maximum frequency achievable. The optimal approach uses binary search on the answer with O(n log n) time complexity, or direct sliding window with prefix sum optimization.

Common Approaches

✓ Dfs

⏱️ Time: N/A Space: N/A

Binary Search on Answer + Sliding Window

⏱️ Time: O(n log n) Space: O(1)

Sort the array first, then binary search on the answer (maximum possible frequency). For each frequency, use sliding window to check if we can make that many consecutive elements equal within k operations.

Brute Force - Try All Targets

⏱️ Time: O(n³) Space: O(n)

For each possible target value, calculate how many operations are needed to make as many elements equal to that target as possible within k operations.

Optimized Sliding Window with Prefix Sum

⏱️ Time: O(n log n) Space: O(n)

After sorting, use a sliding window approach where we try all possible window sizes from largest to smallest. For each window size, we slide through the array and calculate the cost to make all elements equal to the rightmost element using prefix sums.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int canAchieveFreq(int* nums, int n, int k, int freq) {
    if (freq > n) {
        return 0;
    }
    
    long long min_cost = LLONG_MAX;
    
    // Try all possible windows of size freq
    for (int i = 0; i <= n - freq; i++) {
        // Cost to make nums[i:i+freq] all equal to nums[i+freq-1]
        int target = nums[i + freq - 1];
        long long cost = 0;
        for (int j = i; j < i + freq; j++) {
            cost += target - nums[j];
        }
        if (cost < min_cost) {
            min_cost = cost;
        }
    }
    
    return min_cost <= k;
}

int solution(int* nums, int n, int k) {
    qsort(nums, n, sizeof(int), compare);
    
    int left = 1, right = n;
    int result = 1;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (canAchieveFreq(nums, n, k, mid)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse array [1,2,6,1]
    int nums[1000];
    int n = 0;
    
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++; // skip '['
        char* end = strchr(ptr, ']');
        if (end) {
            *end = '\0';
            
            // Parse comma-separated numbers
            char* token = ptr;
            while (token && *token) {
                while (*token == ' ' || *token == ',') token++;
                if (*token == '\0') break;
                
                nums[n] = strtol(token, &token, 10);
                n++;
            }
        }
    }
    
    // Read k
    fgets(line, sizeof(line), stdin);
    int k = atoi(line);
    
    int result = solution(nums, n, k);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ Linear Space

8.5K Views

Medium Frequency

~35 min Avg. Time

245 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen