leetcode---42.接雨水

题目：

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

解题思路：

黑色看成墙，宽度为1，给定数组，每个数代表从左到右墙的高度，雨滴的个数其实就是上图蓝色正方形的个数。

解法一：按行求
开始的想法比较暴力且蠢，leetcode执行超时了，不过还是记录下来，如上示例，数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度，可以看到数组最大数是3，我们可以把该数组看成3行。按照墙的高度把数组[0,1,0,2,1,0,1,3,2,1,2,1] 看成[[0,0,0],[1,0,0],[1,1,0],[0,0,0],[1,1,1…]]。即把一维数组看成二维数组，有墙的位置都置1。

这样来统计雨点数就一目了然了，看上图第1行的水，雨滴被两个‘1’包围。同样，第2，3行也是一样。只要统计出‘1’与‘1’之间有多少个蓝方格即可。所以遍历数组记录墙的索引，求两墙索引之差-1就能统计出所有雨滴。

class Solution:
    def trap(self, data):
        MAX = max(data)
        data_exp = []
        for i in range(len(data)):
            small_data_exp = []
            for j in range(MAX):
                t = data[i]
                if (j<t):
                    small_data_exp.append(1)
                else:
                    small_data_exp.append(0)
            data_exp.append(small_data_exp)
        answer = 0
        for j in range(MAX):
            i_index = []
            for i in range(len(data_exp)):
                if (data_exp[i][j] == 1):
                    i_index.append(i)

            for i in range(len(i_index)):
                if i>=len(i_index)-1:break
                if (i_index[i+1]-i_index[i]>1):
                    answer = answer + i_index[i+1]-i_index[i] -1
        return answer

解法二：栈
这个算法我觉得比较困难，但是很酷，所以记录一下。
说到栈，我们肯定会想到括号匹配了。我们仔细观察蓝色的部分，可以和括号匹配类比下。每次匹配出一对括号（找到对应的一堵墙），就计算这两堵墙中的水。

我们用栈保存每堵墙。当遍历墙的高度的时候，如果当前高度小于栈顶的墙高度，说明这里会有积水，我们将墙的高度的下标入栈。

如果当前高度大于栈顶的墙的高度，说明之前的积水到这里停下，我们可以计算下有多少积水了。计算完，就把当前的墙继续入栈，作为新的积水的墙。

总体的原则就是，

1.当前高度小于等于栈顶高度，入栈，指针后移。

2.当前高度大于栈顶高度，出栈，计算出当前墙和栈顶的墙之间水的多少，然后计算当前的高度和新栈的高度的关系，重复第 2 步。直到当前墙的高度不大于栈顶高度或者栈空，然后把当前墙入栈，指针后移。

我们看具体的例子。

首先将 height [ 0 ] 入栈。然后 current 指向的高度大于栈顶高度，所以把栈顶 height [ 0 ] 出栈，然后栈空了，再把 height [ 1 ] 入栈。current 后移。

然后 current 指向的高度小于栈顶高度，height [ 2 ] 入栈，current 后移。

然后 current 指向的高度大于栈顶高度，栈顶 height [ 2 ] 出栈。计算 height [ 3 ] 和新的栈顶之间的水。计算完之后继续判断 current 和新的栈顶的关系。

current 指向的高度大于栈顶高度，栈顶 height [ 1 ] 出栈，栈空。所以把 height [ 3 ] 入栈。currtent 后移。

然后 current 指向的高度小于栈顶 height [ 3 ] 的高度，height [ 4 ] 入栈。current 后移。
然后 current 指向的高度小于栈顶 height [ 4 ] 的高度，height [ 5 ] 入栈。current 后移。

然后 current 指向的高度大于栈顶 height [ 5 ] 的高度，将栈顶 height [ 5 ] 出栈，然后计算 current 指向的墙和新栈顶 height [ 4 ] 之间的水。计算完之后继续判断 current 的指向和新栈顶的关系。此时 height [ 6 ] 不大于栈顶 height [ 4 ] ，所以将 height [ 6 ] 入栈。current 后移。

然后 current 指向的高度大于栈顶高度，将栈顶 height [ 6 ] 出栈。计算和新的栈顶 height [ 4 ] 组成两个边界中的水。然后判断 current 和新的栈顶 height [ 4 ] 的关系，依旧是大于，所以把 height [ 4 ] 出栈。计算 current 和 新的栈顶 height [ 3 ] 之间的水。然后判断 current 和新的栈顶 height [ 3 ] 的关系，依旧是大于，所以把 height [ 3 ] 出栈，栈空。将 current 指向的 height [ 7 ] 入栈。current 后移。

其实不停的出栈，可以看做是在找与 7 匹配的墙，也就是 3 。

而对于计算 current 指向墙和新的栈顶之间的水，根据图的关系，我们可以直接把这两个墙当做之前解法三的 max_left 和 max_right，然后之前弹出的栈顶当做每次遍历的 height [ i ]。水量就是 Min ( max _ left ，max _ right ) - height [ i ]，只不过这里需要乘上两个墙之间的距离。可以看下代码继续理解下。

class Solution2:
    def trap(self, height) -> int:
        length=len(height)
        if length<3:return 0
        res,idx=0,0
        stack=[]
        while idx<length:
            while len(stack)>0 and height[idx]>height[stack[-1]]:
                top=stack.pop()#index of the last element in the stack
                if len(stack)==0:
                    break
                h=min(height[stack[-1]],height[idx])-height[top]
                print(h)
                dist=idx-stack[-1]-1
                res+=(dist*h)
            stack.append(idx)
            idx+=1
        return res