42. Trapping Rain Water

双指针暴力解法：

每一列雨水的高度，取决于，该列 左侧最高的柱子和右侧最高的柱子中最矮的那个柱子的高度，即： min(lHeight, rHeight) - height

class Solution:
    def trap(self, height):
        if len(height) <= 2:
            return 0

        max_left = [0] * len(height)
        max_right = [0] * len(height)
        n = len(height)

        # 记录每个柱子左边柱子最大高度
        max_left[0] = height[0]
        for i in range(1, n):
            max_left[i] = max(height[i], max_left[i - 1])

        # 记录每个柱子右边柱子最大高度
        max_right[n - 1] = height[n - 1]
        for i in range(n - 2, -1, -1):
            max_right[i] = max(height[i], max_right[i + 1])

        # 求和
        sum_ = 0
        for i in range(n):
            count = min(max_left[i], max_right[i]) - height[i]
            if count > 0:
                sum_ += count

        return sum_
        

单调栈解法：

一旦发现添加的柱子高度大于栈头元素了，此时就出现凹槽了，栈头元素就是凹槽底部的柱子，栈头第二个元素就是凹槽左边的柱子，而添加的元素就是凹槽右边的柱子。

遇到相同的元素，更新栈内下标，就是将栈里元素（旧下标）弹出，将新元素（新下标）加入栈中，因为我们要求宽度的时候 如果遇到相同高度的柱子，需要使用最右边的柱子来计算宽度。

class Solution:
    def trap(self, height):
        result = 0
        stack = [0]
        for i in range(1, len(height)):
            while len(stack) > 0 and height[i] > height[stack[-1]]:
                mid_height = stack.pop()
                if stack:
                    h = min(height[i], height[stack[-1]]) - height[mid_height]
                    w = i - stack[-1] - 1
                    v = h*w
                    result += v
            stack.append(i)
        return result

84. Largest Rectangle in Histogram

只有栈里从大到小的顺序，才能保证栈顶元素找到左右两边第一个小于栈顶元素的柱子。

所以本题单调栈的顺序正好与接雨水反过来。

此时大家应该可以发现其实就是栈顶和栈顶的下一个元素以及要入栈的三个元素组成了我们要求最大面积的高度和宽度

# 单调栈精简
class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        heights.insert(0, 0)
        heights.append(0)
        stack = [0]
        result = 0
        for i in range(1, len(heights)):
            while stack and heights[i] < heights[stack[-1]]:
                mid_height = heights[stack[-1]]
                stack.pop()
                if stack:
                    # area = width * height
                    area = (i - stack[-1] - 1) * mid_height
                    result = max(area, result)
            stack.append(i)
        return result