Maximum Frequency of an Element After Performing Operations II

Maximum Frequency of an Element After Performing Operations II - Problem

Array Binary Search Sliding Window Sorting Prefix Sum Hard

Imagine you have an array of numbers and the power to strategically modify exactly numOperations elements to maximize how many times any single value appears in the final array.

Given an integer array nums and two integers k and numOperations, you must perform exactly numOperations operations. In each operation:

Select an index i that hasn't been selected before
Add any integer in the range [-k, k] to nums[i]

Goal: Return the maximum possible frequency of any element after performing all operations optimally.

Example: With nums = [1, 4, 5], k = 3, and numOperations = 2, you could modify the first two elements to both become 4, giving you three 4's total (frequency = 3).

Input & Output

example_1.py — Basic case with optimal modifications

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

› Output: 3

💡 Note: We can modify the first element (1) by adding 3 to get 4, and modify the third element (5) by subtracting 1 to get 4. This gives us [4, 4, 4] with frequency 3.

example_2.py — Limited operations constraint

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

› Output: 3

💡 Note: Target value 4: Original count = 1, can modify [1,5,2] (3 elements), but limited to 2 operations. Final frequency = 1 + 2 = 3.

example_3.py — Edge case with no modifications needed

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

› Output: 4

💡 Note: All elements are already the same value (5). No modifications needed, so the maximum frequency is 4.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
0 ≤ k ≤ 10⁹
0 ≤ numOperations ≤ nums.length
Each index can be selected at most once

Visualization

Tap to expand

Understanding the Visualization

Smart Range Selection

Instead of testing every possible collection size, use binary search to efficiently narrow down the optimal size

Strategic Target Selection

For each collection size, only consider targets that are achievable from existing paintings (original values ± modification range)

Efficient Verification

Quickly count how many paintings can contribute to each target collection, considering both unchanged and modified pieces

Key Takeaway

🎯 Key Insight: Binary search on the answer combined with smart candidate selection transforms a brute force O(range×n) solution into an efficient O(n log²n) algorithm by only testing promising targets and frequencies.

Asked in

G Google 42 f Meta 38 a Amazon 31 ⊞ Microsoft 29 Apple 22

The optimal approach uses binary search on the answer combined with smart candidate generation. Instead of testing all possible target values, we only consider candidates that are reachable from existing elements (num±k). For each candidate frequency, we verify if it's achievable by counting original matches and available modifications. This reduces time complexity from O(range×n) to O(n log²n), making it efficient even for large inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Target Values)	O(range × n)	O(1)	Test every possible target value and count achievable frequency
Binary Search on Answer + Sliding Window	O(n log n log n)	O(n)	Binary search the maximum frequency, verify using sorted array and sliding window

Brute Force (Try All Target Values) — Algorithm Steps

Determine the range of possible target values (min(nums)-k to max(nums)+k)
For each potential target value:
Count original elements that already equal the target
Count elements that can be modified to reach the target (within k distance)
Take the minimum of (total reachable elements, original count + numOperations)
Track the maximum frequency across all targets

Visualization

Tap to expand

Step-by-Step Walkthrough

Range Setup

Determine the range of possible targets from (min-k) to (max+k)

Target Testing

For each target, count original matches and modifiable elements

Frequency Calculation

Calculate achievable frequency considering operation limit

Code -

solution.c — C

int maxFrequency(int* nums, int numsSize, int k, int numOperations) {
    if (numsSize == 0) return 0;
    
    int minVal = nums[0], maxVal = nums[0];
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < minVal) minVal = nums[i];
        if (nums[i] > maxVal) maxVal = nums[i];
    }
    
    int maxFreq = 0;
    
    // Try all possible target values
    for (int target = minVal - k; target <= maxVal + k; target++) {
        int originalCount = 0;
        int modifiableCount = 0;
        
        for (int i = 0; i < numsSize; i++) {
            if (nums[i] == target) {
                originalCount++;
            } else if (abs(nums[i] - target) <= k) {
                modifiableCount++;
            }
        }
        
        // Can use at most numOperations modifications
        int achievable = originalCount + (modifiableCount < numOperations ? modifiableCount : numOperations);
        if (achievable > maxFreq) {
            maxFreq = achievable;
        }
    }
    
    return maxFreq;
}

Time & Space Complexity

Time Complexity

⏱️

O(range × n)

For each value in the range (max-min + 2k), we iterate through all n elements

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting and tracking maximum

✓ Linear Space

54.2K Views

High Frequency

~25 min Avg. Time

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Target Values) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler