Minimum Number of Seconds to Make Mountain Height Zero

Minimum Number of Seconds to Make Mountain Height Zero - Problem

Array Math Binary Search Greedy Heap (Priority Queue) Medium

Imagine you're the manager of a mountain demolition project where multiple workers need to completely level a mountain to height zero. Each worker has different efficiency levels and works simultaneously with others.

You are given:

mountainHeight - an integer representing the initial height of the mountain
workerTimes - an array where workerTimes[i] represents the base time (in seconds) for worker i

The Challenge: Each worker becomes progressively slower with each unit of height they remove. Specifically, for worker i to reduce the mountain height by x units total, they need:

workerTimes[i] × 1 + workerTimes[i] × 2 + ... + workerTimes[i] × x seconds

This equals workerTimes[i] × (1 + 2 + ... + x) = workerTimes[i] × x × (x + 1) / 2 seconds

Goal: Find the minimum number of seconds needed for all workers combined to reduce the mountain height to exactly zero.

Input & Output

example_1.py — Basic Example

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

› Output: 3

💡 Note: Worker assignments: Worker 1 does 1 unit (2×1×2/2 = 2 sec), Worker 2 does 2 units (1×2×3/2 = 3 sec), Worker 3 does 1 unit (1×1×2/2 = 1 sec). Maximum time is 3 seconds.

example_2.py — Single Worker

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

› Output: 30

💡 Note: Only one worker available. Time needed = 5×3×4/2 = 30 seconds to remove all 3 units of height.

example_3.py — Equal Workers

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

› Output: 18

💡 Note: Each worker does 2 units. Time per worker = 3×2×3/2 = 9 seconds. Since they work simultaneously, total time is 9 seconds. Wait, let me recalculate: each worker can do 2 units in 3×(1+2) = 9 seconds, but we need to verify this is optimal.

Constraints

1 ≤ mountainHeight ≤ 10⁵
1 ≤ workerTimes.length ≤ 10⁴
1 ≤ workerTimes[i] ≤ 10⁶
All workers work simultaneously

Visualization

Tap to expand

Understanding the Visualization

Setup

Multiple workers positioned at different parts of the mountain

Progressive Fatigue

Each worker's nth unit takes n times their base time

Binary Search

Find minimum time by testing if workers can finish within given time limits

Optimal Assignment

Greedily assign maximum possible work to each worker within time constraint

Key Takeaway

🎯 Key Insight: Binary search on the answer combined with greedy capacity calculation gives us the optimal O(n log T) solution, where T is the maximum possible time.

Asked in

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

The optimal approach uses binary search on the answer. We search for the minimum time T where all workers can collectively complete the mountain. For each candidate time, we calculate the maximum work each worker can accomplish using the quadratic formula, then check if the total work meets the mountain height requirement. This achieves O(n log(max_time)) complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Partitions)	O(n^h)	O(h)	Try all possible ways to distribute mountain height units among workers
Binary Search on Answer (Optimal)	O(n log(max_time))	O(1)	Binary search on the final time, checking feasibility with greedy work allocation

Brute Force (Generate All Partitions) — Algorithm Steps

Generate all ways to partition mountainHeight among workers
For each partition, calculate total time as max time among all workers
Worker i taking x units needs workerTimes[i] * x * (x + 1) / 2 seconds
Return the minimum time across all partitions

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with full mountain height to distribute

Assign

Try all possible work amounts for first worker

Recurse

Move to next worker with remaining height

Calculate

When all workers assigned, calculate total time

Code -

solution.c — C

int minTime;

void backtrack(int remaining, int idx, int* assignment, int* workerTimes, int n) {
    if (idx == n) {
        if (remaining == 0) {
            long long maxTime = 0;
            for (int i = 0; i < n; i++) {
                long long time = (long long)workerTimes[i] * assignment[i] * (assignment[i] + 1) / 2;
                if (time > maxTime) maxTime = time;
            }
            if (maxTime < minTime) minTime = maxTime;
        }
        return;
    }
    
    for (int work = 0; work <= remaining; work++) {
        assignment[idx] = work;
        backtrack(remaining - work, idx + 1, assignment, workerTimes, n);
    }
}

int minNumberOfSeconds(int mountainHeight, int* workerTimes, int workerTimesSize) {
    minTime = INT_MAX;
    int* assignment = (int*)calloc(workerTimesSize, sizeof(int));
    
    backtrack(mountainHeight, 0, assignment, workerTimes, workerTimesSize);
    
    free(assignment);
    return minTime;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^h)

Where n is number of workers and h is mountain height - we generate all ways to distribute h units among n workers

✓ Linear Growth

Space Complexity

O(h)

For recursion stack and storing current partition

✓ Linear Space

34.2K Views

Medium Frequency

~25 min Avg. Time

1.5K 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 (Generate All Partitions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler