LeetCode 85. 最大矩形（Hard）/ 223. （需要算重叠部分的）矩形面积（Medium）/ 1139. 最大的以 1 为边界的正方形（Medium）/ 数学相关问题！！！

题目链接

题解

1. Python3 前缀和+单调栈计算最大矩形

思路

代码

class Solution:
    ### 0121 单调栈（84 ms，20.1 MB）
    def maximalRectangle(self, matrix: List[List[str]]) -> int:
        if not matrix: return 0

        res = 0
        m, n = len(matrix), len(matrix[0])

        # 每一行最后多加一个0，初始化0表示右边界的1
        heights = [0] * (n + 1)

        # 根据 行 来遍历，并更新最大矩阵
        for i in range(m):
            # 累积每一行上方 1 的数量，若出现0则中断重新累积
            for j in range(n): # 注意：由于使用了matrix，所以这里只需要n，而非n+1！
                heights[j] = heights[j] + 1 if matrix[i][j] == '1' else 0

            # 每行定义一个单调栈，初始化-1表示左边界的1
            stack = [-1]
            # 注意：由于需要使用heights，所以这里相当于是n+1！
            for k, num in enumerate(heights):
                # 只要有比当前列高的列，就出栈（保证递增）
                while heights[stack[-1]] > num:
                    cur_h = heights[stack.pop()] # 注意：pop已经出栈！
                    cur_w = k - stack[-1] - 1
                    res = max(res, cur_h * cur_w)
                
                # 将本列加入栈中
                stack.append(k)

        return res

223. （需要算重叠部分的）矩形面积（Medium）

• 题解
  

class Solution:
    def computeArea(self, ax1: int, ay1: int, ax2: int, ay2: int, bx1: int, by1: int, bx2: int, by2: int) -> int:
        # 计算2个矩形的面积
        s1 = (ax2 - ax1) * (ay2 - ay1)
        s2 = (bx2 - bx1) * (by2 - by1)
        
        # 计算重叠部分的面积
        a = max(min(ax2, bx2) - max(ax1, bx1), 0) # 重叠部分的长：若为负数，说明未重叠，直接置0
        b = max(min(ay2, by2) - max(ay1, by1), 0) # 重叠部分的宽：若为负数，说明未重叠，直接置0
        
        return s1 + s2 - a * b

1139. 最大的以 1 为边界的正方形

• 题解
  

class Solution:
    # 动态规划
    def largest1BorderedSquare(self, grid):

        m, n = len(grid), len(grid[0])
        left = [[0] * (n + 1) for _ in range(m + 1)]
        up = [[0] * (n + 1) for _ in range(m + 1)]
        maxBorder = 0

        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if grid[i - 1][j - 1]:
                    # 只需两个边即可确定正方形
                    left[i][j] = left[i][j - 1] + 1
                    up[i][j] = up[i - 1][j] + 1
                    
                    # 合法正方形的边长的最大值为left[i][j], up[i][j]二者的最小值
                    border = min(left[i][j], up[i][j])
                    # 从border开始，从大到小进行枚举（遍历），直到枚举到一个合法的正方形即可
                    while left[i - border + 1][j] < border or up[i][j - border + 1] < border:
                        border -= 1
                    
                    maxBorder = max(maxBorder, border)

        return maxBorder ** 2

数学问题！！！

• 数学相关问题