Leetcode - 11: Container With Most Water

Given an array or heights we need to find two height between which the maximum water can be stored


What's the question?

Given n non-negative integers a1, a2, ..., an , where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the two endpoints of the line i is at (i, ai) and (i, 0). Find two lines, which, together with the x-axis forms a container, such that the container contains the most water.

Let's see some examples

Input: height = [1,8,6,2,5,4,8,3,7]
Output: 49

Instead of starting with a bruteforce solution for this problem as, we might have gone through the 2Sum and 2Sum-II problems wherein we use two pointers from the left and the right. We can use the same approach here.

We will start with a maximum area i.e. maxArea of 0 and then as we initialize our pointers to start and end we will calculate the area length * height.

Here the length will become right_ptr - left_ptr as each pole or line is at a distance of 1 unit from each other. But now because we have two pointers we will have to choose either of the one height.

So to choose a height just imagine that if we choose a larger/bigger height out of the two then the water will start splilling from the smaller/shoter height pole so we should choose the shorter pole. Now our area formula will become (right_ptr - left_ptr) * min(height[left_ptr], height[right_ptr]).

Once we compute this area, if this area is larger than the current maxArea we can replace the current maxArea with the computed area. So after every left and right pointer iteration/change we can have the maxArea written as maxArea = max(maxArea, (right_ptr - left_ptr) * min(height[left_ptr], height[right_ptr])).

Let's code this out

def maxArea(height):

    maxArea = 0
    left_ptr = 0
    right_ptr = len(height) - 1

    while left_ptr < right_ptr:

        maxArea = max(maxArea, (right_ptr - left_ptr) * min(height[left_ptr], height[right_ptr]))

        if height[left_ptr] > height[right_ptr]:
            right_ptr -= 1
        elif height[right_ptr] > height[left_ptr]:
            left_ptr += 1
            left_ptr += 1

    return maxArea

So that's it we did this in a single while loop. The logic behind updating the left_ptr and right_ptr is to move the either one when it's smaller than the other. This way we can stay at a higher ground for one pole and keep on checking with different heights of other poles.

That's it for this blog, hope you found this helpful. You can connect with me on Twitter