leetCode 第42題，單調棧典型
//給定 n 個非負整數表示每個寬度為 1 的柱子的高度圖，計算按此排列的柱子，下雨之後能接多少雨水。 
//
// 
//
// 上面是由陣列 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度圖，在這種情況下，可以接 6 個單位的雨水（藍色部分表示雨水）。 感謝 Marcos 貢獻此圖。 
//
// 示例: 
//
// 輸入: [0,1,0,2,1,0,1,3,2,1,2,1]
//輸出: 6 
// Related Topics 棧 陣列 雙指標


import java.util.Stack;

//leetcode submit region begin(Prohibit modification and deletion)
 
class Solution {
    public int trap(int[] height) {
        if (height == null || height.length==0)
            return 0;
        //維護降序棧：遍歷陣列時入棧，入棧規則，當前元素小於棧頂入棧，大於棧頂時，需要依次出站，一直至當前元素小於棧頂
        //當前元素大於棧頂元素時，當前元素為右邊界right。棧頂元素的前一個元素為左邊界left（降序棧）。
        //雨水面積為(min（left，rihht）-hight[stack.peek]（彈出元素高度)) *  (right -left -1),當前元素大於若干個棧元素時，便要計算
 
        //面積的寬度（right -left -1）
         int area = 0;
        Stack<Integer> stack = new Stack<Integer>();
        for(int right = 0 ;right<height.length;right++){
            //大於棧頂時，需要依次出站，一直至當前元素小於棧頂,故不能用if
            while(!stack.empty() && height[right]>height[stack.peek()]){
                //彈出元素的高度
 
                int top = stack.pop();
                if(stack.empty()){
                    break;
                }
                int left =  stack.peek();
                area += (Math.min(height[left],height[right]) - height[top]) * (right-left-1);
            }
            stack.push(right);
        }

      return area;


        //陣列,當前元素i接水的高度，列舉左右邊界max，左邊界left為陣列[0,i-1]高度Max，右邊界right為陣列[i+1，nums.length-1]高度Max
        //由於是逐個元素遍歷，故寬度是1
        //改進，增加leftMax陣列和rightMax陣列快取當前元素的leftMax及rightMax
        int area = 0;
        for(int i=0;i<height.length;i++){
            //當i在為0和height.length-1時，為陣列的左右邊界，此時不會儲水
            if(i==0 || i== height.length-1){
                continue;
            }
            //在[0,i-1]中找leftMax
            int leftMax = 0;
            for(int j=i;j>=0;j--){
                leftMax = Math.max(leftMax,height[j]);
            }
            //在[i+1，nums.length-1]中找rightMax
            int rightMax =0;
            for(int k=i;k<height.length;k++){
                rightMax = Math.max(rightMax,height[k]);
            }
            area += Math.min(leftMax,rightMax)-height[i];

        }
        return  area;


        //改進，增加leftMax陣列和rightMax陣列快取當前元素的leftMax及rightMax
        int area =0;
        int[] leftMax = new int[height.length];
        int[] rightMax = new int[height.length];
        leftMax[0] =height[0];
        for (int i =1; i<height.length;i++){
            leftMax[i] = Math.max(leftMax[i-1],height[i]);
        }

        rightMax[height.length-1] =height[height.length-1];
        for (int i=height.length-2;i>=0;i--){
            rightMax[i] = Math.max(rightMax[i+1],height[i]);
        }
        for (int i=1;i<height.length-1;i++){
            area += Math.min(leftMax[i],rightMax[i])-height[i];
        }
        return area;

        //優化陣列為左右指標,
        // 因當前元素在找leftMax，rightMax時，由min（leftMax，rightMax）決定高度，
        //故先用左右指標分別指向left，right,再記錄leftMax，rightMax，左右指標分別向中間靠攏，過程中，若height[left]<height[right],操作左指標，否則操作右指標，以左指標為例，當前元素若小於leftMax，則計算當前元素儲水面積，
        // area = hight[leftMax] - hight[i] ,若當前元素若大於leftMax。則賦值leftMax = hight[i];
        int left = 0;
        int right = height.length-1;
        int leftMax = 0;
        int rightMax = 0;
        int area =0;
        while(left<right){
            if (height[left]<height[right]){
                if(height[left]<leftMax){
                    area += leftMax-height[left];
                }else {
                    leftMax = height[left];
                }
                left++;
            }else{
                if(height[right]<rightMax){
                    area += rightMax-height[right];
                }else {
                    rightMax = height[right];
                }
                right--;
            }
        }

        return area;

    }
}