接雨水

题目 接雨水

链接:leetcode
给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 感谢 Marcos 贡献此图。

解法一：

从左往右遍历每一列，判断该列上的积水量，当前cur的高度,判断cur两边最高和最矮的高度，进行计算该cur上面会不会有积水.

class Solution {
    public int trap(int[] height) {
        //从左往右遍历每一列，判断该列上的积水量，当前cur的高度,判断cur两边最高和最矮的高度，进行计算该cur上面会不会有积水
        int cur;
        int left_i;
        int right_i;
        int max_left;
        int max_right;
        int max_height;
        int sum = 0;
        
        for(cur = 1; cur < height.length - 1; cur++){
            max_left = 0;
            max_right = 0;
            max_height = 0;
            //遍历左边,寻找最大的max_left;
            for(left_i = cur - 1; left_i >= 0 ; left_i--){
              if(height[left_i] > max_left)
                max_left = height[left_i];
            }
            //遍历右边,寻找最大的max_right;
            for(right_i = cur + 1; right_i < height.length; right_i++){
                if(height[right_i] > max_right)
                max_right = height[right_i];
            }
            //判断左右两边最大高度，寻找最小的高度和当前cur的高度进行对比
            max_height = max_left > max_right ? max_right : max_left;
            sum += max_height > height[cur] ? max_height - height[cur] : 0;
        }
        return sum;
    }
}

执行用时 :
76 ms
内存消耗 :
40.2 MB

解法二：

解法一比较耗时，改用栈求解，类似括号匹配等

class Solution {
    public int trap(int[] height) {
        java.util.Stack<Integer> triStack = new java.util.Stack<Integer>();
        java.util.Stack<Integer> triStackTmp = new java.util.Stack<Integer>();

        int sum = 0;
        int k = 0;
        int maxTmp = 0;
        int wall = 0;
        int top = 0;
        int wallTmp=0;
        for (int i = 0; i < height.length; i++) {//先把所有的高度都放到栈里
            if (triStack.isEmpty()) {
                triStack.push(height[i]);
                continue;
            }
            triStack.push(height[i]);
        }
        int cur;
        while (!triStack.isEmpty()) {//从后往前遍历栈，小于当前值出栈，大于当前值，计算中间产生的积水量。
            cur = triStack.pop();
            k = 0;
            maxTmp = 0;
            wall = 0;
            while (!triStack.isEmpty()) {
                top = triStack.pop();
                wall += top>cur ? cur:top;
                k++;
                if (top < cur && top > maxTmp){//更新最大值高度，同时清空中间的墙
                    maxTmp = top;
                    wallTmp =maxTmp * k - wall;
                    triStackTmp.clear();
                }

                if (top >= cur){//栈顶元素大于当前最开始出栈的元素，及找到了左边最高点，计算积水，当前栈顶元素继续入栈
                    triStack.push(top);
                    if(maxTmp<cur){
                        maxTmp=cur;//可能左边的比右边的高取右边高的部分为max
                        wallTmp =maxTmp * k - wall;
                        triStackTmp.clear();
                    }
                    break;
                }
                triStackTmp.push(top);//计入中间出栈的元素，后续如果左边的高度没有比右边高，需要重新入栈。
            }
            if (maxTmp * k > wall){//更新积水量
                sum += wallTmp;
                while(!triStackTmp.isEmpty()){
                    triStack.push(triStackTmp.pop());
                }
            }
        }
        return sum;       
    }
}

执行用时 :
8 ms
内存消耗 :
37 MB