(python stack) leetcode84 Largest Rectangle in Histogram And 85. Maximal Rectangle

本文链接：https://blog.csdn.net/weixin_42001089/article/details/84203651

这道题使用的知识点是：栈

从左到右，如果当前对应的小矩形高度大于栈顶对应小矩形高度，进栈，移动到下一个小矩形，，，，，，，，，

否则栈顶元素出栈，再次比较此时栈顶元素和当前对应的小矩形高度，如果前者还是大于后者，继续出栈，直到小于等于为止

依次计算上面一次连续出栈的小矩形组成的矩形面积，最大面积依此不断更新

最后返回最大面积

注意：这里每次进栈的是小矩形对应的索引而不是其高度，同时可以看到stack中索引对应的高度始终是递增的

下面就以[2,1,5,6,3,2]为例看一下该算法过程：

设stack为栈，i为当前小矩形的索引用红色表示，索引所对应的小矩形高度用黄色表示，最大面积用result表示

首先在待求序列末尾加一个0变为[2,1,5,6,3,2,0]

当i=0时：

进栈，stack=[0]

当i=1时：

因为heights[1]=1<heights[0]=2 出栈，栈为空了，1进栈，计算出栈小矩形的面积result = 2，

当i=2时：

此时stack = [1] 因为heights[2]=5>heights[1]=1 进栈

当i=3时：

同理进栈

当i=4时：

此时stack = [1,2,3] 因为heights[4]=3<heights[3]=6 出栈

此时stack = [1,2] 因为heights[4]=3<heights[2]=5 出栈

此时stack = [1] 因为heights[4]=3>heights[1]=1 ,4 进栈

上面这一系列出栈的索引有2和3，计算这两个索引对应的矩形组成的面积即高度是5和6这两个矩形，

第一次出栈时面积是6，第二次出栈时，此时两个组合面积是10

更新result为10

当i=5时：

此时stack = [1,4] 因为heights[5]=2<heights[4]=3 出栈

此时stack = [1] 因为heights[5]=2>heights[1]=1 ,5进栈

上面这一系列出栈的索引有4，计算这个索引对应的矩形组成的面积即高度是3这个矩形，面积是3

更新result，最大值还应该是10

当i=6时：

此时stack = [1,5] 因为heights[6]=0<heights[5]=3 出栈

此时stack = [1] 因为heights[6]=0<heights[1]=1 ,出栈

此时栈为空，6进栈

第一次出栈时面积是3，第二次出栈时组合是5

更新result，最大值还应该是10

结束。。。。。。。。。。。。。。。。。。

给一下python代码：

class Solution:
    def largestRectangleArea(self, heights):
        """
        :type heights: List[int]
        :rtype: int
        """
      
        heights.append(0)
        stack = []
        i = 0
        result = 0
        while i<len(heights):
            if not stack or heights[stack[-1]]<heights[i]:
                stack.append(i)
                i+=1
            else:
                num = stack.pop(-1)
                result = max(result,heights[num]*(i-stack[-1]-1 if stack else i))
        return result

注意这里的

i-stack[-1]-1

就是当前出栈的所有矩阵宽度之和（间隔），说白了就是我们要计算面积的宽，当stack为空的时候，也就是全出栈啦，此时宽度就是i

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

说到这里如果还是不太懂的话，我们来从另一个角度试着解释一下：

假如现在是一个升序的序列：

1,4,6,8,14,56,59

那么解此题是不是就简单多了，我们只需要比较：

1*7 4*6 6*5 8*4 14*3 56*2 59*1

可以看到很简单吧

那么如果不是升序的序列呢？我们就想办法让其升序，于是乎就有了上述的利用栈来实现

其实栈内就是维护的一个升序序列，其永远是一个升序序列

当当前元素大于栈顶元素的时候，毫无疑问就是进栈，升序嘛

当不是升序的时候，例如当到下图的5时，

我们就计算2,3,4这个子升序序列的最大值

此时栈内元素应该剩下1啦，接下来5,6,7连续进栈，到8时又不满足升序了，于是

我们就计算5,6,7这个子升序序列的最大值，

需要注意的是：

这里不单单是计算

5*3 6*2 7*1这三个值，其实还有一个是5*6，其实就是图中红色和天蓝色的这个子序列（2,3,4,5,6,7）

所以这类算法有一点需要特别注意的就是：

在计算出栈的一系列计算中，到了最后一个满足出栈的元素时，千万注意，其要考虑上次所有出栈元素的情况。

只有这样才将所有情况考虑周全

下面再看一道其变种的题型：

思路如出一辙：

n=int(input())
arr=[int(x) for x in input().split()]
stack = []
arr.append(0)
result = 0
i = 0
presum = []
tempsum = 0
while i<len(arr):
    if not stack or arr[i]>=stack[-1]:
        presum.append(tempsum)
        tempsum = 0
        stack.append(arr[i])
        i+=1
    else:
        temp = stack.pop(-1)
        tempsum+=(temp+presum.pop())
        result = max(tempsum*temp,result)
print(result)

需要注意这里的presum，其的作用就是我们上面所说的，当最后一个满足的元素出栈时，其要考虑前面的情况，

例如：

47,59,81,18,25,40,56,4

开始47,59,81连续进栈，当遇见18时

三个出栈并计算这个子升序序列的最大值

接着18,25,40,56进栈

当遇到4时，18,25,40,56出栈并计算这个子升序序列的最大值

按照我们的思路就是56先出栈，那么就算56*56

然后40 出栈计算40*（40+56）

然后 25 出栈就算25*（25+40+56）

最后18出栈计算18*（18+25+40+56）

代码中的tempsum其实就是上面括号的内容

但是可以看到我们是不是忘了47,59,81,18,25,40,56这个序列呢即遗忘了这个值：

18*（47+59+81+18+25+40+56）

所以说当最后一个满足的元素出栈时（这里是18），其要考虑前面的情况

即不再是18*（18+25+40+56）

而是连同上一次出栈的情况即47，59，81

所以是：18*[（18+25+40+56）+(47+59+81)]

原因就是根据我们进栈的规则可以得到：上一次出栈的所有元素的值都是比我们这轮最后一个出栈的值要大的

所以对应当前轮最后一个出栈的元素其左延伸能到达的最远处不是本身而是上一轮出栈的所有元素的最左面

非最后一个出栈的元素其左延伸能到达的最远处都是自身

至于右延伸最远到达的位置二者都一样，就是当前轮第一个出栈的元素

最后说一下代码：

代码中的presum就是这里所说的 (47+59+81)

这里的巧妙之处在于：

当本轮出栈的元素不是最后一个时presum pop出的是0，当是最后一个元素时，其pop出的正是上一轮所有出栈元素的总和

对应到47,59,81,18,25,40,56,4的解释就是：

当18 进栈是，此时tempsum=(47+59+81),

于是presum.append(empsum),presum中就有了(47+59+81)

以后当25进栈时tempsum被赋予了0，于是presum中就是(47+59+81)，0

同理40进栈，presum中就是(47+59+81)，0，0

56进栈，presum中就是(47+59+81)，0，0,0

当遇到4的时候，需要计算本轮出栈的情况了

56 先出栈，其不是本轮最后一个出栈的元素，对应presum.pop正好也是0

40 出栈，presum.pop正好也是0

25 出栈，presum.pop正好也是0

18 出栈，其是本轮最后一个出栈的元素，presum.pop正好也是(47+59+81)

说白了：在本轮第一个元素进栈的时候，我们presum append的是上一轮所有出栈元素的总和，当第二个，第三个,,,,,,,,,,,等等后续元素进栈的时候我们presum append都是0,所以在出栈计算的时候，只不过是把presum中的元素相反的抛出。

上面的解决方案可以作为一个封装的子模块去解决更加复杂的问题，比如下面这道题：

上了上面的基础，这道题迎刃而解，我们可以一行一行来处理

将当前行即以上看为矩形，矩形的高度就是1的个数，比如对应第二行

那么矩形的盖度就是2,0,1,1,1

然后利用我们上面讨论的largestRectangleArea函数去计算当前的最大面积

然后进行下一行，直到结束。

那么每一行对应的矩形高度怎么计算呢？这就是一个简单的动态规划DP问题了，即如果当前行某一列对应的元素是1，那么其高度就是上行对应列的高度加一，否则为0

下面贴一下代码：

class Solution:
    def maximalRectangle(self, matrix):
        """
        :type matrix: List[List[str]]
        :rtype: int
        """
        if len(matrix)==0:
            return 0
        
        row = len(matrix)
        column = len(matrix[0])
        temp = [0 for i in range(column)]
        i = 0
        result = 0
        while i<row:
            for j in range(column):
                temp[j] = (0 if matrix[i][j]=='0' else temp[j]+1)
            result = max(result, self.largestRectangleArea(temp))
            i+=1
        return result
                    
    def largestRectangleArea(self, heights):
        """
        :type heights: List[int]
        :rtype: int
        """
        heights.append(0)
        stack = []
        i = 0
        result = 0
        while i<len(heights):
            if not stack or heights[stack[-1]]<heights[i]:
                stack.append(i)
                i+=1
            else:
                num = stack.pop(-1)
                result = max(result,heights[num]*(i-stack[-1]-1 if stack else i))
        return result

这里的temp就是当前对应行对应的矩阵高度，它是实时更新的。

这里顺便分析一下复杂度

假设matrix是m*n的

因为在进行每一行时，想要遍历当前列得到temp所以是O(n)，然后使用largestRectangleArea函数计算当前列最大面积，又需要遍历一遍即O（n）,所以一共是O(n+n)=O(n)

一共是m行，所以总的时间复杂度就是O(m*n)

空间复杂度的话因为用了一个长度为n的列表temp，所以空间复杂度就是O（n）

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------