No.011：Container With Most Water

问题：

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 line i is at (i, ai) 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.

官方难度：

Medium

翻译：

给定n个非负整数a1,a2,...,an，每一个数值代表坐标轴上的坐标(i,ai)。

画上n条垂直于横坐标的竖线，用于连接点(i,ai)和(i,0)。找到两条线，与x轴一起形成一个容器，能够容纳最多的水。

注意容器不能倾斜。

方法一：

1. 利用一个二次循环，同时维护一个最大面积max。

方法一的解题代码：

     private static int method_1(int[] height) {
         int max = 0;
         for (int i = 0; i < height.length - 1; i++) {
             for (int j = i + 1; j < height.length; j++) {
                 int area = Math.min(height[i], height[j]) * (j - i);
                 if (max < area) {
                     max = area;
                 }
             }
         }
         return max;
     }

method_1

方法二：

1. 显然第一种方法的效率是极低的。
2. 我们注意到，虽然高是由输入决定的，但是底的值却是可控的。有一个思想，维护一个最大高度maxHeight记录遇到的最大高度，在内循环中自后向前遍历，这样一来，底的值始终在减小。这就意味着只需要考虑高的值，就能决定整个容器的面积。所以在遇到小于maxHeight的情况时，可以直接跳过本次循环，不需要再次计算面积。

方法二的解题代码：

     private static int method_2(int[] height) {
         int max = 0;
         for (int i = 0; i < height.length; i++) {
             int maxHeight = 0;
             // 内循环反向遍历
             for (int j = height.length - 1; j > i; j--) {
                 int h = Math.min(height[i], height[j]);
                 // 因为底越来越小，所以只有高度大于最高高度，才有比较面积的意义
                 if (h > maxHeight) {
                     // 不考虑面积比较结果，高先赋值
                     maxHeight = h;
                     if (h * (j - i) > max) {
                         max = h * (j - i);
                     }
                 }
             }
         }
         return max;
     }

method_2

方法三：

1. 方法二仍然是一个时间复杂度为O(n^2)的二次循环，但是还有优化的策略。
2. 在一次内循环结束之后，进入下一次内循环，如果height[i]小于上一次的长度，可以直接跳过这次循环。这样一来看似二次循环的问题，可以通过从两侧向中间夹逼，转化为一次循环的问题。

方法三的解题代码：

     public static int maxArea(int[] height) {
         if (height == null || height.length < 2) {
             throw new IllegalArgumentException("Input error");
         }
         // 初始面积
         int left = 0, right = height.length - 1;
         int area = (right - left) * Math.min(height[left], height[right]);
         // 左右侧开始的最长高度
         int leftMax = height[left];
         int rightMax = height[right];
         // 从两侧向中间夹逼，即底在不断变小
         while (left < right) {
             if (height[left] < height[right]) {
                 left++;
                 // 更小的高没有比较价值
                 if (height[left] <= leftMax) {
                     continue;
                 } else {
                     leftMax = height[left];
                 }
                 area = Math.max(area, (right - left) * Math.min(height[left], height[right]));
             } else {
                 right--;
                 if (height[right] <= rightMax) {
                     continue;
                 } else {
                     rightMax = height[right];
                 }
                 area = Math.max(area, (right - left) * Math.min(height[left], height[right]));
             }
         }
         return area;
     }

maxArea

相关链接：

https://leetcode.com/problems/container-with-most-water/

https://github.com/Gerrard-Feng/LeetCode/blob/master/LeetCode/src/com/gerrard/algorithm/medium/Q011.java

PS：如有不正确或提高效率的方法，欢迎留言，谢谢！