Minimum Operations to Exceed Threshold Value II

Minimum Operations to Exceed Threshold Value II - Problem

You are given a 0-indexed integer array nums, and an integer k. You are allowed to perform some operations on nums, where in a single operation, you can:

Select the two smallest integers x and y from nums.
Remove x and y from nums.
Insert (min(x, y) * 2 + max(x, y)) at any position in the array.

Note that you can only apply the described operation if nums contains at least two elements.

Return the minimum number of operations needed so that all elements of the array are greater than or equal to k.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: Operation 1: combine 1,2 → 1×2+2=4, array=[4,11,10]. Operation 2: combine 4,10 → 4×2+10=18, array=[18,11]. Operation 3: combine 11,18 → 11×2+18=40, array=[40]. All elements ≥ 10, so 3 operations needed.

Example 2 — Already Valid

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

› Output: 0

💡 Note: All elements are already ≥ 1, so no operations needed.

Example 3 — Single Small Element

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

› Output: 4

💡 Note: Need multiple operations to combine small elements until all reach threshold 20.

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
1 ≤ k ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 f Meta 20 a Amazon 18

The key insight is to always combine the two smallest elements first for optimal growth. The best approach uses a min heap to efficiently access the smallest elements in O(log n) time per operation. Time: O(n log n), Space: O(n).

Common Approaches

✓ Brute Force with Array Sorting

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

For each operation, sort the entire array to find the two smallest elements, remove them, and insert their combination. Continue until all elements meet the threshold.

Optimal Solution with Min Heap

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

Use a min heap (priority queue) to always access the two smallest elements in O(log n) time. This eliminates the need for sorting the entire array repeatedly.

Brute Force with Array Sorting — Algorithm Steps

Check if all elements >= k
Sort array to find two smallest
Remove smallest two and add their combination
Repeat until done

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Array

Start with unsorted array

Sort & Combine

Sort entire array, take two smallest, combine them

Repeat

Continue until all elements ≥ k

Code -

solution.c — C

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

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

int min(int a, int b) {
    return a < b ? a : b;
}

int max(int a, int b) {
    return a > b ? a : b;
}

int solution(int* nums, int numsSize, int k) {
    int* arr = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        arr[i] = nums[i];
    }
    
    int operations = 0;
    int currentSize = numsSize;
    
    while (1) {
        // Check if all elements >= k
        int allValid = 1;
        for (int i = 0; i < currentSize; i++) {
            if (arr[i] < k) {
                allValid = 0;
                break;
            }
        }
        
        if (allValid || currentSize < 2) {
            break;
        }
        
        // Sort to find two smallest
        qsort(arr, currentSize, sizeof(int), compare);
        
        // Take two smallest
        int x = arr[0], y = arr[1];
        
        // Remove them and add combination
        for (int i = 0; i < currentSize - 2; i++) {
            arr[i] = arr[i + 2];
        }
        currentSize -= 2;
        
        int combination = min(x, y) * 2 + max(x, y);
        arr[currentSize] = combination;
        currentSize++;
        
        operations++;
    }
    
    free(arr);
    return operations;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        if (strlen(token) > 0) {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(nums, numsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

Up to n operations, each requiring O(n log n) sorting

⚡ Linearithmic

Space Complexity

O(1)

Only using variables for tracking, modifying array in-place

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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 with Array Sorting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler