"Minimize the maximum" and "maximize the minimum" sound similar, but they require opposite binary search logic. Confusing them leads to wrong answers.
This guide teaches you how to recognize each pattern, the exact template for each, and the key differences in feasibility and pointer updates.
Minimize Maximum:
right = midMaximize Minimum:
left = mid + 1Problem structure: "What's the minimum [capacity/speed/load] such that [constraint] is satisfied?"
Examples:
Feasibility direction: If answer x works, larger values also work
Answer: [1, 2, 3, 4, 5, 6, 7, 8]
Feasible: [F, F, F, T, T, T, T, T]
↑
Find first T (minimum)Template:
def minimize_maximum(min_val, max_val, is_feasible):
left, right = min_val, max_val
while left < right:
mid = left + (right - left) // 2
if is_feasible(mid):
# mid works, try smaller
right = mid
else:
# mid doesn't work, need larger
left = mid + 1
return left # Minimum feasible valueProblem structure: "What's the maximum [distance/force/gap] such that [constraint] is satisfied?"
Examples:
Feasibility direction: If answer x works, smaller values also work
Answer: [1, 2, 3, 4, 5, 6, 7, 8]
Feasible: [T, T, T, T, T, F, F, F]
↑
Find last T (maximum)Template:
def maximize_minimum(min_val, max_val, is_feasible):
left, right = min_val, max_val
result = min_val
while left <= right:
mid = left + (right - left) // 2
if is_feasible(mid):
# mid works, try larger
result = mid
left = mid + 1
else:
# mid doesn't work, need smaller
right = mid - 1
return result # Maximum feasible valueMinimize Maximum:
Maximize Minimum:
Ask: "If answer x works, what about x+1?"
If x+1 also works: Minimize Maximum
If x+1 might not work: Maximize Minimum
| Aspect | Minimize Maximum | Maximize Minimum |
|---|---|---|
| Goal | Find smallest feasible | Find largest feasible |
| Feasibility | If x works, x+1 works | If x works, x-1 works |
| Search for | First True | Last True |
| Pointer update (feasible) | right = mid | left = mid + 1 |
| Pointer update (infeasible) | left = mid + 1 | right = mid - 1 |
| Loop condition | left < right | left <= right |
| Return | left | result |
Problem: Find minimum eating speed to finish all bananas in h hours.
Pattern: Minimize Maximum (minimize speed)
Why: If speed k works, speed k+1 also works (faster is always ok)
Solution:
def minEatingSpeed(piles, h):
def can_finish(speed):
hours = sum((pile + speed - 1) // speed for pile in piles)
return hours <= h
left, right = 1, max(piles)
while left < right:
mid = left + (right - left) // 2
if can_finish(mid):
right = mid # Try smaller speed
else:
left = mid + 1 # Need faster speed
return left # Minimum speedProblem: Place m balls to maximize minimum distance between any two balls.
Pattern: Maximize Minimum (maximize distance)
Why: If distance d works, distance d-1 also works (smaller is easier)
Solution:
def maxDistance(position, m):
position.sort()
def can_place(min_dist):
count = 1
last_pos = position[0]
for pos in position[1:]:
if pos - last_pos >= min_dist:
count += 1
last_pos = pos
if count == m:
return True
return count >= m
left, right = 1, position[-1] - position[0]
result = 1
while left <= right:
mid = left + (right - left) // 2
if can_place(mid):
result = mid # Try larger distance
left = mid + 1
else:
right = mid - 1 # Need smaller distance
return result # Maximum distance❌ Wrong (Minimize Maximum):
if is_feasible(mid):
left = mid + 1 # WRONG: should try smaller✅ Correct:
if is_feasible(mid):
right = mid # Try smaller for minimize❌ Wrong (Maximize Minimum):
while left < right: # WRONG: should be <=✅ Correct:
while left <= right: # Correct for maximize❌ Wrong:
# Using minimize template for maximize problem✅ Correct:
# Identify pattern first, then use correct templateMinimize Maximum:
Maximize Minimum:
5. Magnetic Force Between Two Balls (#1552)
6. Aggressive Cows (classic problem)
7. Maximize Minimum Distance (variations)
Step 1: Identify the optimization goal
├─ "Minimize the maximum" → Pattern 1
└─ "Maximize the minimum" → Pattern 2
Step 2: Verify feasibility direction
├─ If x works, does x+1 work? → Minimize Maximum
└─ If x works, does x-1 work? → Maximize Minimum
Step 3: Choose template
├─ Minimize Maximum: right = mid, left < right
└─ Maximize Minimum: left = mid + 1, left <= rightQ: How do I remember which is which?
A: Minimize Maximum: Find first True (smallest that works)
Maximize Minimum: Find last True (largest that works)
Q: Can I use the same template for both?
A: No. The pointer updates and loop conditions are different.
Q: What if the problem doesn't say "minimize" or "maximize"?
A: Rephrase it. "What's the minimum X to achieve Y?" → Minimize Maximum
Q: Why different loop conditions?
A: Minimize uses left < right with right = mid (keeps mid as potential answer)
Maximize uses left <= right with result tracking (standard binary search)
Minimize Maximum and Maximize Minimum are opposite patterns that require different templates.
Key differences:
right = mid vs left = mid + 1< vs <=Recognition:
Templates:
right = midleft = mid + 1Master both patterns and you'll solve optimization problems with confidence. For more details, see Binary Search on Answer and Why Binary Search on Answer Works.
LeetCopilot is a free browser extension that enhances your LeetCode practice with AI-powered hints, personalized study notes, and realistic mock interviews — all designed to accelerate your coding interview preparation.
Also compatible with Edge, Brave, and Opera
Add to Chrome for free