Maximum Frequency of an Element After Performing Operations II - Problem

Array Binary Search Sliding Window Sorting Prefix Sum Hard

You are given an integer array nums and two integers k and numOperations.

You must perform an operation exactly numOperations times on nums, where in each operation you:

Select an index i that was not selected in any previous operations
Add an integer in the range [-k, k] to nums[i]

Return the maximum possible frequency of any element in nums after performing the operations.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: Choose target value 4. Modify nums[0]: 2→4 and nums[2]: 6→4. Result: [4,4,4] with frequency 3.

Example 2 — Limited Operations

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

› Output: 2

💡 Note: Choose target value 4. Only nums[2] can be modified: 5→4 (since |1-4|=3 > k=1). Result: [1,4,4] with frequency 2.

Example 3 — No Operations Needed

$ Input: nums = [3,3,3], k = 1, numOperations = 1

› Output: 3

💡 Note: All elements are already equal to 3. No operations needed, frequency is already 3.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
0 ≤ k ≤ 10⁹
0 ≤ numOperations ≤ nums.length

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 M Microsoft 8

The key insight is to realize that for any target value, we should greedily assign operations to elements that are closest to the target. The best approach uses binary search on the answer combined with greedy verification. For each candidate frequency, we test all possible target values and greedily assign operations to minimize modification costs. Time: O(n² log n), Space: O(n).

Common Approaches

✓ Greedy

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

Binary Search on Answer

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

Use binary search to find the maximum frequency. For each candidate frequency, greedily check if we can achieve it by optimally assigning operations to make elements equal to some target value.

Brute Force - Try All Targets

⏱️ Time: O(n³ × 2^n) Space: O(n)

For each possible target value, determine the maximum frequency by trying all combinations of which elements to modify and how to modify them within the [-k, k] range.

Sliding Window with Sorting

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

Sort the array and use a sliding window approach to find ranges where we can make the maximum number of elements equal with the given operations and constraint k.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int nums[100005];
static int candidates[200010];

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

int solution(int* arr, int n, int k, int numOperations) {
    if (n == 0) return 0;
    
    // Generate all possible target values
    int candidateCount = 0;
    for (int i = 0; i < n; i++) {
        candidates[candidateCount++] = arr[i];
        candidates[candidateCount++] = arr[i] - k;
        candidates[candidateCount++] = arr[i] + k;
    }
    
    // Sort and remove duplicates
    qsort(candidates, candidateCount, sizeof(int), compare_int);
    int uniqueCount = 1;
    for (int i = 1; i < candidateCount; i++) {
        if (candidates[i] != candidates[uniqueCount - 1]) {
            candidates[uniqueCount++] = candidates[i];
        }
    }
    
    int maxFreq = 0;
    
    // Try each candidate as target value
    for (int t = 0; t < uniqueCount; t++) {
        int target = candidates[t];
        int reachable = 0;  // Elements that can reach target
        int operations = 0; // Operations needed for elements that require them
        
        for (int i = 0; i < n; i++) {
            if (arr[i] == target) {
                reachable++;
            } else if (abs(arr[i] - target) <= k) {
                reachable++;
                operations++;
            }
        }
        
        // Calculate maximum frequency achievable
        int freq;
        if (operations <= numOperations) {
            freq = reachable;
        } else {
            // We can only operate on numOperations elements
            // Count elements that are already equal to target
            int alreadyEqual = 0;
            for (int i = 0; i < n; i++) {
                if (arr[i] == target) {
                    alreadyEqual++;
                }
            }
            freq = alreadyEqual + numOperations;
        }
        
        if (freq > maxFreq) {
            maxFreq = freq;
        }
    }
    
    return maxFreq;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    
    // Find opening bracket
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse number
        char* endptr;
        int num = (int)strtol(p, &endptr, 10);
        if (endptr != p) {
            arr[(*size)++] = num;
            p = endptr;
        } else {
            p++;
        }
    }
}

int main() {
    char line[10000];
    
    // Read array
    fgets(line, sizeof(line), stdin);
    int n;
    parseArray(line, nums, &n);
    
    // Read k
    fgets(line, sizeof(line), stdin);
    int k = atoi(line);
    
    // Read numOperations
    fgets(line, sizeof(line), stdin);
    int numOperations = atoi(line);
    
    int result = solution(nums, n, k, numOperations);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

8.8K 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