Minimum Operations to Make Array Values Equal to K

Minimum Operations to Make Array Values Equal to K - Problem

You are given an integer array nums and an integer k. Your goal is to make all elements in the array equal to k using a special operation.

But first, let's understand the concept of a valid integer:

An integer h is called valid if all values in the array that are strictly greater than h are identical.
For example, if nums = [10, 8, 10, 8], then h = 9 is valid because all elements > 9 are equal to 10, but h = 5 is not valid because elements > 5 include both 8 and 10.

Operation: Select a valid integer h and set all elements greater than h to h.

Return the minimum number of operations required to make every element equal to k, or -1 if it's impossible.

Input & Output

example_1.py — Basic Case

$ Input: {"nums": [2, 11, 10, 1, 3], "k": 1}

› Output: 4

💡 Note: We need 4 operations: 11→10 (h=10), 10→3 (h=3), 3→2 (h=2), 2→1 (h=1). Each operation reduces one unique value > k.

example_2.py — Impossible Case

$ Input: {"nums": [1, 2, 3, 4, 5], "k": 10}

› Output: -1

💡 Note: Since all elements (1,2,3,4,5) are less than k=10, it's impossible to make them equal to 10 using the allowed operations.

example_3.py — Already Equal

$ Input: {"nums": [5, 5, 5, 5], "k": 5}

› Output: 0

💡 Note: All elements are already equal to k=5, so no operations are needed.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
1 ≤ k ≤ 10⁶
All operations must use valid h values

Visualization

Tap to expand

Understanding the Visualization

Survey Buildings

Check all building heights - if any is shorter than target, impossible

Identify Unique Heights

Find all unique heights taller than target k

Count Regulations

Each unique height > k needs one regulation operation

Apply in Order

Process from tallest to shortest for valid regulations

Key Takeaway

🎯 Key Insight: The number of operations equals the number of unique values greater than k. Process them in descending order for valid regulations.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses a greedy approach with hash sets. The key insight is that each unique value greater than k requires exactly one operation. Simply count these unique values - if any element is less than k, return -1 as it's impossible.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy with Hash Set (Optimal)	O(n log n)	O(n)	Collect unique values > k, then process them in descending order
Brute Force (Try All Possible Operations)	O(2^n)	O(n)	Try all possible valid operations at each step and explore all paths

Greedy with Hash Set (Optimal) — Algorithm Steps

Check if any element is less than k (impossible case)
Collect all unique values greater than k using a hash set
Sort unique values in descending order
Count operations: each unique value > k requires one operation
Return the count of unique values > k

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Validity

Verify no element is less than k

Collect Unique

Find all unique values greater than k

Count Operations

Each unique value > k needs exactly one operation

Return Result

The count equals minimum operations needed

Code -

solution.c — C

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

int minOperations(int* nums, int numsSize, int k) {
    // If any element is less than k, it's impossible
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < k) {
            return -1;
        }
    }
    
    // Collect unique values greater than k
    int unique[10000]; // Assuming reasonable bounds
    int uniqueCount = 0;
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] > k) {
            // Check if already exists
            int found = 0;
            for (int j = 0; j < uniqueCount; j++) {
                if (unique[j] == nums[i]) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                unique[uniqueCount++] = nums[i];
            }
        }
    }
    
    // Each unique value > k requires one operation
    return uniqueCount;
}

int main() {
    int nums[] = {2, 11, 10, 1, 3};
    int k = 1;
    printf("%d\n", minOperations(nums, 5, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) to collect unique values, O(k log k) to sort where k ≤ n unique values

⚡ Linearithmic

Space Complexity

O(n)

Hash set stores at most n unique values

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Greedy with Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler