Minimum Number of Seconds to Make Mountain Height Zero - Problem

Array Math Binary Search Greedy Heap (Priority Queue) Medium

You are given an integer mountainHeight denoting the height of a mountain. You are also given an integer array workerTimes representing the work time of workers in seconds.

The workers work simultaneously to reduce the height of the mountain. For worker i:

To decrease the mountain's height by x, it takes workerTimes[i] + workerTimes[i] * 2 + ... + workerTimes[i] * x seconds.

For example:

To reduce the height of the mountain by 1, it takes workerTimes[i] seconds.
To reduce the height of the mountain by 2, it takes workerTimes[i] + workerTimes[i] * 2 seconds, and so on.

Return an integer representing the minimum number of seconds required for the workers to make the height of the mountain 0.

Input & Output

Example 1 — Basic Case

$ Input: mountainHeight = 4, workerTimes = [2,1,1]

› Output: 3

💡 Note: Worker 1 reduces 1 unit (time: 2), Worker 2 reduces 2 units (time: 1+2=3), Worker 3 reduces 1 unit (time: 1). Maximum time is 3.

Example 2 — Single Worker

$ Input: mountainHeight = 3, workerTimes = [3]

› Output: 18

💡 Note: Only worker reduces all 3 units: 3×1 + 3×2 + 3×3 = 3 + 6 + 9 = 18 seconds.

Example 3 — Equal Workers

$ Input: mountainHeight = 5, workerTimes = [1,1]

› Output: 6

💡 Note: Optimal distribution: Worker 1 gets 3 units (1+2+3=6), Worker 2 gets 2 units (1+2=3). Maximum time is 6.

Constraints

1 ≤ mountainHeight ≤ 10⁵
1 ≤ workerTimes.length ≤ 10⁴
1 ≤ workerTimes[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 10 f Meta 8

The key insight is to use binary search on the answer - the total time needed. For each candidate time, we check if workers can collectively reduce the mountain to zero using the quadratic formula to determine maximum units each worker can complete. Best approach is Binary Search on Answer with Time: O(log(maxTime) × n × √h), Space: O(1).

Common Approaches

✓ Binary Search on Answer

⏱️ Time: O(log(maxTime) × n × √h) Space: O(1)

The key insight is to binary search on the answer (total time). For each candidate time, we check if all workers can collectively reduce the mountain height to zero within that time using a greedy approach.

Brute Force - Try All Assignments

⏱️ Time: O(mountainHeight^workerCount) Space: O(mountainHeight)

For each possible assignment of height units to workers, calculate the total time needed. The brute force approach tries every combination where the sum of assigned units equals mountainHeight.

Greedy with Priority Queue

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

Use a priority queue to track each worker's next completion time. Always assign the next height unit to the worker who can finish their current work earliest, ensuring optimal load balancing.

Binary Search on Answer — Algorithm Steps

Set binary search bounds: low=1, high=sum of all work for one worker
For each mid time, check if workers can finish the job
Use greedy assignment: give work to fastest available worker
Narrow search space based on feasibility

Visualization

Tap to expand

Step-by-Step Walkthrough

Set Bounds

Low=1, High=maximum possible time needed

Check Mid Time

Can all workers finish the job in mid time?

Narrow Search

Adjust bounds based on feasibility

Code -

solution.c — C

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

// Integer square root to avoid math.h
long long isqrt(long long n) {
    if (n < 2) return n;
    long long left = 1, right = n;
    while (left <= right) {
        long long mid = left + (right - left) / 2;
        if (mid <= n / mid) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return right;
}

long long maxUnitsInTime(int workerTime, long long totalTime) {
    if (totalTime < workerTime) return 0;
    
    // Binary search for maximum x such that workerTime * x * (x + 1) / 2 <= totalTime
    long long left = 0;
    long long right = isqrt(2 * totalTime / workerTime) + 1;
    
    while (left <= right) {
        long long mid = (left + right) / 2;
        long long cost = (long long)workerTime * mid * (mid + 1) / 2;
        if (cost <= totalTime) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return right;
}

int canFinishInTime(long long targetTime, int mountainHeight, int* workerTimes, int workerCount) {
    long long totalUnits = 0;
    for (int i = 0; i < workerCount; i++) {
        totalUnits += maxUnitsInTime(workerTimes[i], targetTime);
        if (totalUnits >= mountainHeight) return 1;
    }
    return 0;
}

long long solution(int mountainHeight, int* workerTimes, int workerCount) {
    long long left = 1;
    int minWorkerTime = workerTimes[0];
    for (int i = 1; i < workerCount; i++) {
        if (workerTimes[i] < minWorkerTime) {
            minWorkerTime = workerTimes[i];
        }
    }
    long long right = (long long)minWorkerTime * mountainHeight * (mountainHeight + 1) / 2;
    
    while (left < right) {
        long long mid = left + (right - left) / 2;
        if (canFinishInTime(mid, mountainHeight, workerTimes, workerCount)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    return left;
}

int main() {
    int mountainHeight;
    scanf("%d", &mountainHeight);
    
    char line[1000];
    scanf(" %[^\n]", line);
    
    int workerTimes[100];
    int workerCount = 0;
    char* ptr = line + 1;
    while (*ptr && *ptr != ']') {
        workerTimes[workerCount++] = atoi(ptr);
        while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
        if (*ptr == ',') ptr++;
    }
    
    printf("%lld\n", solution(mountainHeight, workerTimes, workerCount));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log(maxTime) × n × √h)

Binary search iterations × workers × calculating max units per worker using quadratic formula

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables for binary search and calculations

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~35 min Avg. Time

856 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

Minimum Number of Seconds to Make Mountain Height Zero - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler