LeetCode：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.

题目大意：二维坐标轴上有n个点[i, ai]，每个点画一条x轴的垂线（连接[i, ai]和[i, 0]），选两条线作为盆子装水，找出最多水的方案
**/
import java.util.*;

public class Solution {
    public int maxArea(int[] height) {
        //return solve1(height);      //超时
        //return solve2(height);      //想法错误
        //return solve3(height);
        return solve4(height);
    }
    
    //================================ solve1 ========================================
    //O(n^2)
    //双循环直接穷举，必然超时
    private int solve1(int[] height){
        int result = -1;
        int index = -1;
        
        for(int i=0; i<height.length; i++){
            for(int j=i+1; j<height.length; j++){
                index = i;
                if(height[i] > height[j])
                    index = j;
                
                int water = height[index] * (j-i);
                if(result < water)
                    result = water;
            }
        }
        
        return result;
    }
    
    //================================ solve2 ========================================
    //想法本身有问题，没能维护两点之间的宽度，算出来的果断是错误答案
    //O(n * log2 n) = O(n * log2 n) + O(n)
    //先对数组进行排序，然后遍历，对于[i, ai]，直接乘以他到最优的距离就可以得出当前点可容纳最多水的数量
    private int solve2(int[] height){
        Arrays.sort(height);
        
        int result = -1;
        int tmp = -1;
        
        for(int i=0; i<height.length; i++){
            tmp = height[i] * (height.length - 1 - i);  //注意这里要减1才能得到宽度
            
            if(result < tmp)
                result = tmp;
        }
        return result;
    }
    
    //================================ solve3 ========================================
    //O(m^2) = O(n) + O(n) + O(m^2)
    //搜索左端点 + 搜索右端点 + 查询并获取最大值
    /**
    考虑从这个题目本身的数学性质出发：
        现在指定两点[i, ai],[j, aj]，面积f(1)=(j-i)*min(ai, aj)，固定左端点，移动右端点：
            1、右端点右移，有两种情况：
                [j+k, b1]，其中b1>=aj，则f(b1)=(j+k-i)*min(ai, b1)，明显可得f(b1)>f(1)；
                [j+k, b2]，其中b2<=aj，则f(b2)=(j+k-i)*min(ai, b2)，f(b2)和f(1)大小不定；
            2、右端点左移，也有两种情况：
                [j-k, c1]，其中c1>=aj，则f(b1)=(j-k-i)*min(ai, c1)，f(c1)和f(1)大小不定；
                [j-k, c2]，其中c2<=aj，则f(b2)=(j-k-i)*min(ai, c2)，明显可得f(c2)<f(1)；
        
        左端点的情况和右端点对称，可以得出结论：如果程序从两端开始，向中间收缩，只能选择越来越高的点才能保证容量不变小。
    
    例如，序列是[5(0),4(1),6(2),12(3),8(4),32(5),9(6),1(7),4(8)]，
        左端点i的选择只能是：0 -> 2 -> 3 -> 5
        右端点j的选择只能是：8 -> 6 -> 5
        可以从这一点出发，对水盆左右端点的情况进行缩减
    **/
    private int solve3(int[] height){
        int[] leftPoint = new int[height.length];
        int leftNum = 0;
        
        int[] rightPoint = new int[height.length];
        int rightNum = 0;
        
        //选取左端点集合：
        for(int i=0, currentPoint=height[i]; i<height.length; i++){
            if(height[i] >= currentPoint){
                leftPoint[leftNum++] = i;
                currentPoint = height[i];
            }
        }
        
        //选取右端点集合：
        for(int i=height.length-1, currentPoint=height[i]; i>=0; i--){
            if(height[i] >= currentPoint){
                rightPoint[rightNum++] = i;
                currentPoint = height[i];
            }
        }
        
        //在所得的点里开始计算
        //这里可以有一个优化的策略：当一端静止，另一端向其靠近，如果另一端的高度比这一端要高，那就可以结束当前循环了
        int result = -1;
        for(int i=0; i<leftNum; i++){
            for(int j=0; j<rightNum; j++){    //在这里可以加一个条件
                int left = leftPoint[i];
                int right = rightPoint[j];
                if(left >= right)
                    break;
                int width = right - left;
                
                //这里要用矮的那一个作为盆子的高度
                int tall = min(height[left], height[right]);
                
                int water = tall * width;
                if(result < water)
                    result = water;
            }
        }
        
        return result;
    }
    
    //================================ solve4 ========================================
    //O(n)
    //左右靠拢，到中间合并的时候必然可得最大值
    /**
    现在试试左右两端往中间收窄的策略：
        当固定其中一端i，另一端j向其靠近，如果发现 height[j] >= height[i]；
        那么这个时候j就不需要在靠近了，因为即使在靠近，高度也限制在i点上，无法增加，
        此时应固定j点，转由i点向j点靠近。
        同时对中间每一步产生的容量值进行计算，得出最大值。
        
    其实使用了solve3的一些结论，在这里只移动矮的那一边，因为移动高的那一边没有意义
    计算完毕之后一定能得到最大值
    **/
    private int solve4(int[] height){
        int left = 0;
        int right = height.length - 1;
        
        int result = -1;
        
        while(left < right){
            int tmp = (right - left) * min(height[left], height[right]);
            
            result = max(result, tmp);
            
            if(height[left] <= height[right])
                left++;
            else
                right--;
        }
        return result;
    }
    
    private int min(int a, int b){
        if(a < b)
            return a;
        else
            return b;
    }
    
    private int max(int a, int b){
        if(a < b)
            return b;
        else
            return a;
    }
}