LeetCode 3296 – Minimum Number of Seconds to Make Mountain Height Zero

In this tutorial we will solve LeetCode 3296: Minimum Number of Seconds to Make Mountain Height Zero. This is an advanced algorithm problem that combines Binary Search, Mathematics, and Greedy reasoning.

---

Problem Summary

You are given:

• A mountain with height H
• An array workerTimes

Each worker removes mountain blocks but the time required increases for every block.

Blocks Removed	Time Required
1	t
2	t + 2t
3	t + 2t + 3t
x	t(1 + 2 + 3 + ... + x)

Using the triangular number formula:

1 + 2 + 3 + ... + x = x(x + 1) / 2

So the total time becomes:

time = t * x(x + 1) / 2

Our goal is to find the minimum seconds required to reduce mountain height to zero.

---

Example Walkthrough

mountainHeight = 4
workerTimes = [2,1,1]

Possible distribution:

Worker	Blocks Removed	Time Taken
Worker A	1	2
Worker B	2	3
Worker C	1	1

Total blocks removed:

1 + 2 + 1 = 4

Workers operate simultaneously. Total time:

max(2,3,1) = 3 seconds

---

Key Insight

Instead of assigning blocks directly, we ask: For a worker with time t:

t * x(x+1) / 2 ≤ T

Solving the equation gives:

x = floor((-1 + √(1 + 8T/t)) / 2)

This tells us how many blocks that worker can remove.

---

Binary Search Strategy

We search the minimum possible time.

left = 0
right = very large number

Algorithm:

while(left < right)

    mid = (left + right)/2

    if workers can remove mountain in mid seconds
        right = mid
    else
        left = mid + 1

Answer = left

---

Java Implementation

class Solution {

    public long minNumberOfSeconds(int mountainHeight, int[] workerTimes) {

        long left = 0;
        long right = (long)1e18;

        while (left < right) {

            long mid = left + (right - left) / 2;

            if (canReduce(mid, mountainHeight, workerTimes)) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }

        return left;
    }

    private boolean canReduce(long time, int H, int[] workerTimes) {

        long total = 0;

        for (int t : workerTimes) {

            long val = (long)Math.sqrt(1 + (8.0 * time) / t);
            long x = (val - 1) / 2;

            total += x;

            if (total >= H)
                return true;
        }

        return total >= H;
    }
}

---

Complexity Analysis

Time Complexity

O(n log answer)

Space Complexity

O(1)

---

Key Pattern to Remember

Whenever you see problems with:

• Multiple workers
• Minimum time
• Parallel processing

Think immediately about: Similar problems:

• Minimum Time to Complete Trips
• Minimum Time to Repair Cars
• Factory Machines Problems

---

Conclusion

LeetCode 3296 may look difficult at first, but the core trick is recognizing the triangular time pattern and applying binary search on time. Once you identify the formula:

t * x(x + 1) / 2

the problem becomes much easier to solve efficiently.

---

FAQs

Why do we use Binary Search in this problem?

Because we are searching for the minimum time where the workers can finish the task.

Why is the triangular number formula used?

Because each block removal takes increasing time.

What category does this problem belong to?

Binary Search on Answer + Math optimization.