leetcode.84 leetcode739. 每日温度（都是单调栈）

                                 学习不息，转载不止。

---

                         后面有自己写的题解。别忘了。 

---

单调栈学习建议以及练习（15:54 开始）：「力扣」第 42、739、496、316、901、402、581 题。 

---

 这是一个非常典型的利用单调栈来解决 顺序和大小综合问题的题。
单调栈特别适合解决那些，两头大小决定中间值的大小的题。

因为单调栈中，以单调增栈为例。
设栈顶元素为 b， 栈顶第二个元素为a，自然有 a < b （因为堆栈越往上越大）
这时候， 若c出现，且c小于b， 那么b的左右第一个比b小的两个元素就找到了，分别是a和c，b在中间最大。
这时候你可以处理b，并重新整理堆栈，使其保持递增。
若c大于b，那c入栈，继续循环就行了。
最后清理堆栈

单调栈的结构：

for i  in  list:
    while i is not empty and stack[-1] > i: 先调整位置。
        stack.pop()
    stack.append(i)  #当前元素无论如何也要放进去，不同的只是需不需要pop来调整位置

作者：allen-238
链接：https://leetcode-cn.com/problems/largest-rectangle-in-histogram/solution/ji-jian-python-shen-du-jie-xi-dan-diao-dui-zhan-zu/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

这个题的关键点在于：
以B点为高的矩形的最大宽度为， 从a到c， 其中a，c分别为B左边和右边第一个小于B的元素。
单调栈的特点在于：
当遇见大数的时候， 压入堆栈，等待之后处理。
当遇见小数c的时候，意味着大数b的右边界c已经确定了。
这时候开始pop， 而以被pop出来的值（b）为高度的矩形的左右边界需要被确定。
其右边界就是当前的小数。即为c。左边界是堆栈下一层的元素，因为下一层的元素一定比当前小。且是第一小的元素。这时候a也确定了。
则以被pop出来的数为高度的矩形是 (c - a - 1) * pop()， 这里pop() == b

这里细节需要注意的是，

1. 栈底要垫上-1，表示栈底。
2. 循环结束，要清理堆栈。此时所有栈中继续存放的元素的右边界c都是结尾len(height)-1

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        stack = [-1]
        max_res = 0
        for i in range(len(heights)):
            while len(stack) > 1 and heights[i] <= heights[stack[-1]]:
                max_res = max(max_res, heights[stack.pop()] * (i - stack[-1] - 1))  
            stack.append(i)
        for i in range(len(stack)-1):
            max_res = max(max_res, heights[stack.pop()]*(len(heights)-1-stack[-1]))
        return max_res

作者：allen-238
链接：https://leetcode-cn.com/problems/largest-rectangle-in-histogram/solution/ji-jian-python-shen-du-jie-xi-dan-diao-dui-zhan-zu/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

---

自己写的题解：

 这个题的思路：

对于每一个高度heights[i]，如果想要求它能确定的最大矩形面积，我们可以通过枚举i的左右两端的高度，然后确定heights[i]能确定的最大矩形面积。（暴力做法，On^2）。

转换思路：

对每一个heights[i]求它的左右两端最早小于heights[i]的下标，这样我们就知道了heights[i]能确定的矩形最大面积。这里出现了最早小于，显然符合单增栈的性质。

利用单增栈，我们可以很快地找到第一个比当前入栈元素小的元素。所以，这里我们可以考虑用单调栈。

数据结构：

单增栈 （idx_stack）：

像那个例题，Bad Hair Day 一样，栈中我们存放元素的高度么？这样显然不可以（这样我不会做），因为矩形的面积不仅取决于高度，还取决于元素的下标差。所以，栈中我们存放元素下标。。。。。（看懂程序、学会方法就行了，这个题告诉我们，单调栈里不仅仅可以存放高度）

左右数组(left，right):

#left[i]存储的是左边第一个比heights[i]小的元素的下标。

#right[i]存储的是右边第一个比heights[i]小的元素的下标。

算法实现：

分别从左向右和从右向左遍历heights数组（下面以从左向右说明）：

根据单调栈的性质:left[i]存储的是左边第一个比heights[i]小的元素的下标。

代码：

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        n=len(heights)
        left,right,=[0]*n,[0]*n
        
        #保存下标的栈
        idx_stack=list()
        
        #从左到右遍历
        for i in range(n):
        #利用单增栈的性质：能找到从i向左第一个比他小的元素。
            while idx_stack and heights[idx_stack[-1]]>=heights[i]:
                idx_stack.pop()
            #left[i]存储的是左边第一个比heights[i]小的元素的下标。
            left[i]=idx_stack[-1] if idx_stack else -1
            idx_stack.append(i)
        
        idx_stack=list()
        
        #从右向左遍历
        for i in range(n-1,-1,-1):
        #利用单增栈的性质：能找到从i向右第一个比他小的元素。
            while idx_stack and heights[idx_stack[-1]]>=heights[i]:
                idx_stack.pop()
            #right[i]存储的是右边第一个比heights[i]小的元素的下标。    
            right[i]=idx_stack[-1] if idx_stack else n
            idx_stack.append(i)
         
        ans=max((right[i]-left[i]-1)*heights[i] for i in range(n)) if n>0 else 0
        return ans

---

下面的题解是针对739. 每日温度

 思路：

根据题意：每一个元素 T[i]找到第一个在它右边的比它大的元素。

首先我们用暴力的方法去想，如果对每一个 i 枚举它的右边，时间复杂度为ON^2，会超时。根据枚举的思路和题目意思，我们知道找到第一个在它右边的比它大的元素即可。所以，我们可以考虑使用单调栈。

由于单调栈的性质，我们要使用单调递减的栈，并且栈中元素为下标，出栈条件为：T[stk[-1]]<=T[i] 当前下标对应的元素大小小于栈顶对应T的元素大小。因为温度是靠后找，所以我们要从后向前遍历数组维护单调栈。

总结：

充分利用了单调递减的栈的性质：a入栈时，栈不为空，则当前栈顶元素b比要入栈的元素a大；栈为空，则没有比a大的元素。

代码： 

class Solution:
    def dailyTemperatures(self, T: List[int]) -> List[int]:
        stk, n = list(), len(T)
        right = n * [0]

        for i in range(n - 1, -1, -1):
            while stk and T[stk[-1]] <= T[i]:
                stk.pop()

            right[i] = stk[-1] - i if stk else 0
            stk.append(i)
        return right