Leetcode Container With Most Water

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

Note: You may not slant the container.

Idea:

Simplest way is enumerating all possible combination. Time complexity is O(N^2), which is too large.

Another solution is two pointer.  First make two pointer left and right point to 0 and len-1 of the array.

Compare height[left] and height(right), If height[left] > height(right), we know height[right] is the bottleneck. Calculate (right-left)*height[right]. Now we are sure that  for every rectangle ends in right = len-1, the area contained must be less than (right-left)*height[right], since that the width must be less than (right-left) while the height bottleneck cannot be larger that height[right].

If height[left] <= height(right), calculate (right-left)*height[left]. Now we are sure that  for every rectangle starts in left=0, the area contained must be less than (right-left)*height[left], since that the width must be less than right-left while height bottleneck cannot be larger than height[left].

Next narrow down the target rectangle width. We narrow down in the bottleneck position. That is, if height[left] > height(right), right--, otherwise left++.

When left and right meets we can stop, and the current max rectangle is the result we want.

code:

public class Solution {
    public int maxArea(int[] height) {
        int left = 0;
        int right = height.length-1;
        int max = 0;
        while(left<right){
            if(height[left]<height[right]){
                max = Math.max(max, (right-left)*height[left]);
                left++;
            }else{
                max = Math.max(max, (right-left)*height[right]);
                right--;
            }
        }
        return max;
    }
}

time complexity is O(n), space complexity is constant. But this code cannot pass leetcode large test case. Rewrite in C++ it passes

class Solution {
public:
    int maxArea(vector<int>& height) {
        int left = 0;
        int right = height.size()-1;
        int res = 0;
        while(left<right){
            if(height[left]>height[right]){
                res = max(res, (right-left)*height[right]);
                right--;
            }else{
                res = max(res, (right-left)*height[left]);
                left++;
            }
        }
        return res;
    }
};