Minimum Operations to Exceed Threshold Value II

Minimum Operations to Exceed Threshold Value II - Problem

Minimum Operations to Exceed Threshold Value II

You're given a 0-indexed integer array nums and an integer k. Your goal is to make all elements in the array greater than or equal to k using the minimum number of operations.

In each operation, you can:
1. Select the two smallest integers x and y from the array
2. Remove both x and y from the array
3. Insert a new value (min(x, y) * 2 + max(x, y)) at any position

Important: You can only perform this operation if the array contains at least 2 elements.

Example: If you have [2, 11, 10, 1, 3] and k = 10, you could take the two smallest values 1 and 2, remove them, and insert (1 * 2 + 2) = 4.

Return the minimum number of operations needed to achieve your goal.

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: After one operation, nums becomes [4, 11, 10, 3] (combined 1 and 2). After second operation, nums becomes [7, 11, 10] (combined 4 and 3). After third operation, nums becomes [17, 11] (combined 7 and 10). Now all elements are >= 10.

example_2.py — All Elements Already Valid

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

› Output: 0

💡 Note: All elements are already greater than or equal to k=1, so no operations needed.

example_3.py — Single Small Element

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

› Output: 4

💡 Note: We need multiple operations: [1,1,2,4,9] -> [3,2,4,9] -> [5,4,9] -> [9,9] -> [18] but 18 < 20, so we need one more element to combine with, which means we continue until we have valid elements.

Constraints

1 ≤ nums.length ≤ 2 × 10⁵
1 ≤ nums[i], k ≤ 10⁹
Important: The operation can only be performed if the array has at least 2 elements

Visualization

Tap to expand

Understanding the Visualization

Initial Products

Start with products of quality [2,11,10,1,3] and target quality k=10

Find Weakest

Use conveyor belt (heap) to bring forward products 1 and 2

Upgrade Process

Combine using formula: min(1,2)*2 + max(1,2) = 4

Repeat Process

Continue with [4,11,10,3], next combine 4 and 3 to get 7

Key Takeaway

🎯 Key Insight: Using a min-heap eliminates the need to repeatedly scan for smallest elements, reducing time complexity from O(n²) to O(n log n)

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses a min-heap (priority queue) to efficiently maintain access to the two smallest elements. Instead of scanning the entire array repeatedly (O(n²)), we can extract and insert elements in O(log n) time, giving us an overall complexity of O(n log n). The key insight is that we only need the smallest elements at each step, making a heap the perfect data structure.

Common Approaches

Approach	Time	Space	Notes
✓ Priority Queue (Min-Heap) - Optimal	O(n log n)	O(n)	Use a min-heap to efficiently get the two smallest elements in each operation
Brute Force (Linear Search)	O(n²)	O(1)	Repeatedly find two smallest elements by scanning the entire array

Priority Queue (Min-Heap) - Optimal — Algorithm Steps

Create a min-heap and add all elements from the array
While heap has >= 2 elements and smallest element < k:
Extract the two smallest elements from heap
Combine them using the formula: min(x,y)*2 + max(x,y)
Push the combined value back to heap
Increment operation counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Heap

Create min-heap from [2,11,10,1,3]

Extract Min

Pop 1 and 2 (two smallest)

Insert Combined

Push 4 back to heap

Continue

Repeat until all elements >= k

Code -

solution.c — C

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

typedef struct {
    int *data;
    int size;
    int capacity;
} MinHeap;

MinHeap* createHeap(int capacity) {
    MinHeap* heap = malloc(sizeof(MinHeap));
    heap->data = malloc(capacity * sizeof(int));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void bubbleUp(MinHeap* heap, int index) {
    while (index > 0) {
        int parent = (index - 1) / 2;
        if (heap->data[parent] <= heap->data[index]) break;
        swap(&heap->data[parent], &heap->data[index]);
        index = parent;
    }
}

void bubbleDown(MinHeap* heap, int index) {
    while (1) {
        int minIndex = index;
        int leftChild = 2 * index + 1;
        int rightChild = 2 * index + 2;
        
        if (leftChild < heap->size && heap->data[leftChild] < heap->data[minIndex]) {
            minIndex = leftChild;
        }
        if (rightChild < heap->size && heap->data[rightChild] < heap->data[minIndex]) {
            minIndex = rightChild;
        }
        if (minIndex == index) break;
        
        swap(&heap->data[index], &heap->data[minIndex]);
        index = minIndex;
    }
}

void push(MinHeap* heap, int val) {
    heap->data[heap->size] = val;
    bubbleUp(heap, heap->size);
    heap->size++;
}

int pop(MinHeap* heap) {
    int min = heap->data[0];
    heap->data[0] = heap->data[heap->size - 1];
    heap->size--;
    bubbleDown(heap, 0);
    return min;
}

int minOperations(int* nums, int numsSize, int k) {
    MinHeap* heap = createHeap(numsSize * 2);
    
    for (int i = 0; i < numsSize; i++) {
        push(heap, nums[i]);
    }
    
    int operations = 0;
    
    while (heap->size >= 2 && heap->data[0] < k) {
        int x = pop(heap);
        int y = pop(heap);
        
        int combined = (x < y ? x : y) * 2 + (x > y ? x : y);
        push(heap, combined);
        
        operations++;
    }
    
    int result = operations;
    free(heap->data);
    free(heap);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

We may need up to O(n) operations, and each heap operation takes O(log n) time

⚡ Linearithmic

Space Complexity

O(n)

The heap stores all elements of the array

⚡ Linearithmic Space

43.4K Views

High Frequency

~18 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

Priority Queue (Min-Heap) - Optimal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler