Container With Most Water Explained: Tracing [1, 8, 6, 2, 5, 4, 8, 3, 7]

Imagine you are handed an array of vertical wall heights: $h=[1,8,6,2,5,4,8,3,7]$. Your goal is to pick two walls that, together with the horizontal x-axis, form a basin capable of holding the maximum possible volume of water. The area of water held between any two indices $L$ and $R$ is strictly bounded by the shorter wall multiplied by the distance between them: $\text{Area}=\min (h_L,h_R)\times (R-L)$.

If you approach this with a naive mindset, you might think: "Why not just test every single pair of walls?" With $n$ walls, there are $\frac{n(n-1)}{2}$ unique pairs. For our array of length 9, that means checking 36 combinations. But what if $n=100,000$? Checking every pair balloons into billions of operations, causing your code to time out.

Without a smarter strategy, you find yourself pointlessly recalculating areas for pairs that are obviously too narrow or too short to ever beat your current record. We need a way to strategically discard impossible pairs without ever actually computing their area.

When we look at our locked working example heights $h=[1,8,6,2,5,4,8,3,7]$, we are trying to maximize the area of a rectangle. The area formula depends strictly on two things: the horizontal distance between our left and right lines, and the limiting height of the shorter line.

If we start with our pointers at the extreme ends of the array, $L=0$ (height 1) and $R=8$ (height 7), our width is at its absolute maximum of $8-0=8$. However, our height is bottlenecked by $\min (1,7)=1$, yielding an initial area of $8\times 1=8$.

To find a larger container, we cannot just guess randomly; we need a systematic elimination rule. Since the width shrinks by 1 unit with every step we take inward, the only way to find a larger area is to find a significantly taller limiting boundary. This physical constraint gives rise to the greedy two-pointer reduction model.

Now that we have established our two-pointer geometric model, let us trace it step-by-step through our locked array. We want to see how the pointers narrow down the search space without missing the optimal container, maintaining a running maximum area along the way.

* Heights array: $[1,8,6,2,5,4,8,3,7]$ of length $n=9$.
* Initial Pointers: Left pointer $L=0$ at height 1, Right pointer $R=8$ at height 7.

* $L=0$ ($height=1$), $R=8$ ($height=7$).
* Width = $8-0=8$.
* Height limited by left pointer: $\min (1,7)=1$.
* Current area = $8\times 1=8$.
* Update max area: $\max (0,8)=8$.
* Since $height[L](1)<height[R](7)$, increment $L$ to 1.

* $L=1$ ($height=8$), $R=8$ ($height=7$).
* Width = $8-1=7$.
* Height limited by right pointer: $\min (8,7)=7$.
* Current area = $7\times 7=49$.
* Update max area: $\max (8,49)=49$.
* Since $height[L](8)>height[R](7)$, decrement $R$ to 7.

The algorithm terminates when $L$ meets $R$ at index 4, having successfully identified the maximum possible trapped water area of 49 between indices 1 and 8.

Try this: Given L = 1 (height 8) and R = 7 (height 3), calculate the width, limiting height, and resulting area for this specific step.

Now that you have traced the two-pointer dance on our original heights array [1, 8, 6, 2, 5, 4, 8, 3, 7], let us see how the algorithm behaves when we alter the distribution. Consider a modified height array where the peak heights are shifted: [2, 3, 4, 5, 18, 17, 6].

Imagine setting your left pointer $L=0$ at height 2 and your right pointer $R=6$ at height 6. Ask yourself which pointer will move on the very first step, and what the resulting container area will be after that first evaluation. Walk through the comparison of the boundary heights before updating your indices.

def test_modified_container():
    heights = [2, 3, 4, 5, 18, 17, 6]
    # Given L = 0 (val 2) and R = 6 (val 6):
    # 1. What is the initial area?
    # 2. Which pointer increments/decrements?
    pass

We started our journey with the locked array [1, 8, 6, 2, 5, 4, 8, 3, 7] and watched our two pointers converge from width 8 down to 1, safely discarding suboptimal pairs without missing the maximum area of 49. That dramatic reduction from $O(n^2)$ down to $O(n)$ time did not rely on water or physics; it relied on a strict monotonic trade-off: moving the shorter boundary was the only way to potentially find a taller height that could compensate for a shrinking width.

Now, imagine you are given a completely different scenario: searching for two numbers in a sorted array that sum up to a specific target value. Instead of maximizing area between vertical lines, you are tuning a sum. But notice how the mechanics rhyme with our container walkthrough. If the current sum is too small, which pointer must you advance to increase the sum? If the sum is too large, which pointer must you retreat? Recognizing this invariant allows you to take the exact same inward-shrinking rhythm we used on our heights array and apply it to sorted numerical search spaces.

To test this transfer of knowledge, consider how you would adapt the pointer-movement rule for a problem where you want to find two indices whose product equals a target, or where you need to check if a string is a palindrome by comparing outer characters inward. In each case, the underlying mental model remains identical: start at the widest possible boundaries, evaluate the objective function, and discard the side that guarantees no better outcome.

def generalized_transfer_check(arr, target):
    # TODO: Apply the outer-inward pointer convergence pattern
    # learned from the container problem to a new search domain.
    pass