Maximum Frequency of an Element After Performing Operations I

Maximum Frequency of an Element After Performing Operations I - Problem

Array Binary Search Sliding Window Sorting Prefix Sum Medium

You are given an integer array nums and two integers k and numOperations. Your goal is to maximize the frequency of any element in the array after performing exactly numOperations operations.

In each operation, you must:

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

The key insight is that you can strategically modify elements to make them converge to the same value, thereby maximizing the frequency of that target value.

Example: If nums = [1, 4, 5], k = 3, and numOperations = 2, you could:

Add +2 to nums[0] → nums becomes [3, 4, 5]
Add -1 to nums[1] → nums becomes [3, 3, 5]

Now the value 3 appears twice, giving us a maximum frequency of 2.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: We can modify 1 to 4 (add +3) and 5 to 4 (add -1). Now we have [4, 4, 4] with two 4's using 2 operations, giving frequency 2.

example_2.py — No Operations

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

› Output: 3

💡 Note: Without any operations, the maximum frequency is 3 (three 2's already present).

example_3.py — Large K Value

$ Input: nums = [1, 10, 100], k = 50, numOperations = 2

› Output: 3

💡 Note: We can convert all numbers to the same value, e.g., convert 1→51 (+50) and 100→51 (-49). All three numbers can become 51.

Visualization

Tap to expand

Understanding the Visualization

Survey the Field

Look at where all arrows currently landed (original array values)

Identify Targets

Find promising target values that multiple archers can reach

Calculate Distances

For each target, measure how far each archer needs to adjust

Optimize Coaching

Use your limited coaching sessions on the archers closest to the target

Find Best Target

Choose the target that maximizes the number of hits

Key Takeaway

🎯 Key Insight: The optimal target is always reachable from existing positions. We don't need to check impossible targets, just find the sweet spot where the most archers can converge!

Time & Space Complexity

Time Complexity

⏱️

O(n log n log(max_val))

Binary search on answer * verification cost per candidate

⚡ Linearithmic

Space Complexity

O(n)

Space for sorting and temporary arrays

⚡ Linearithmic Space

Constraints

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

Asked in

G Google 42 f Meta 28 a Amazon 35 ⊞ Microsoft 19

The optimal solution uses binary search on the answer combined with efficient feasibility checking. We binary search on the maximum possible frequency (1 to n) and for each candidate frequency, verify if it's achievable by testing promising target values. The key insight is that we only need to test targets that are reachable from existing array elements within the range ±k.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Answer	O(n log n log(max_val))	O(n)	Binary search on maximum possible frequency, verify feasibility for each candidate
Brute Force (Try All Targets)	O(R * n log n)	O(n)	Try every possible target value and count maximum achievable frequency

Binary Search on Answer — Algorithm Steps

Binary search on the maximum frequency from 1 to n
For each candidate frequency, check if it's achievable:
Try different target values and see if we can get that many elements
Use sliding window or efficient counting to verify feasibility
Return the maximum achievable frequency

Visualization

Tap to expand

Step-by-Step Walkthrough

Search Space

Binary search between 1 and n for maximum frequency

Feasibility Check

For each candidate frequency, verify if achievable

Target Testing

Test promising target values for the candidate frequency

Narrow Search

Update search bounds based on feasibility

Code -

solution.c — C

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

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

bool canAchieveFreq(int* nums, int numsSize, int k, int numOperations, int targetFreq) {
    // Get unique candidate targets
    int *candidates = (int*)malloc(numsSize * 3 * sizeof(int));
    int candCount = 0;
    
    for (int i = 0; i < numsSize; i++) {
        candidates[candCount++] = nums[i];
        candidates[candCount++] = nums[i] - k;
        candidates[candCount++] = nums[i] + k;
    }
    
    // Remove duplicates (simple approach)
    qsort(candidates, candCount, sizeof(int), compare);
    int uniqueCount = 1;
    for (int i = 1; i < candCount; i++) {
        if (candidates[i] != candidates[uniqueCount-1]) {
            candidates[uniqueCount++] = candidates[i];
        }
    }
    
    for (int c = 0; c < uniqueCount; c++) {
        int target = candidates[c];
        int exactCount = 0;
        int *reachable = (int*)malloc(numsSize * sizeof(int));
        int reachCount = 0;
        
        for (int i = 0; i < numsSize; i++) {
            if (nums[i] == target) {
                exactCount++;
            } else if (abs(nums[i] - target) <= k) {
                reachable[reachCount++] = abs(nums[i] - target);
            }
        }
        
        qsort(reachable, reachCount, sizeof(int), compare);
        
        int opsUsed = 0;
        int additional = 0;
        for (int i = 0; i < reachCount && opsUsed < numOperations; i++) {
            additional++;
            opsUsed++;
        }
        
        if (exactCount + additional >= targetFreq) {
            free(reachable);
            free(candidates);
            return true;
        }
        
        free(reachable);
    }
    
    free(candidates);
    return false;
}

int maxFrequency(int* nums, int numsSize, int k, int numOperations) {
    int left = 1, right = numsSize;
    int result = 1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (canAchieveFreq(nums, numsSize, k, numOperations, mid)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n log(max_val))

Binary search on answer * verification cost per candidate

⚡ Linearithmic

Space Complexity

O(n)

Space for sorting and temporary arrays

⚡ Linearithmic Space

Constraints

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

23.4K Views

Medium-High Frequency

~18 min Avg. Time

847 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler