最大正方形

题目

在一个由 ‘0’ 和 ‘1’ 组成的二维矩阵内，找到只包含 ‘1’ 的最大正方形，并返回其面积。

示例 1：

输入：matrix = [[“1”,“0”,“1”,“0”,“0”],[“1”,“0”,“1”,“1”,“1”],[“1”,“1”,“1”,“1”,“1”],[“1”,“0”,“0”,“1”,“0”]]
输出：4

示例 2：

输入：matrix = [[“0”,“1”],[“1”,“0”]]
输出：1

示例 3：
输入：matrix = [[“0”]]
输出：0

提示：

m == matrix.length
n == matrix[i].length
1 <= m, n <= 300
matrix[i][j] 为 ‘0’ 或 ‘1’

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximal-square
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

暴力法

由于正方形的面积等于边长的平方，解此题首先需要找到最大正方形的边长，然后计算最大边长的平方。

• 遍历矩阵中的每个元素，每次遇到 1，就将该元素记为正方形的左上角；

• 确定正方形的左上角后，根据左上角所在的行和列计算可能的最大正方形的边长（而正方形的范围不能超出矩阵的行数和列数），在该边长范围内寻找只包含 1 的最大正方形；

• 每次在下方新增一行以及在右方新增一列，判断新增的行和列是否满足所有元素都是 1。

• 时间复杂度：O(mnmin(m,n) ²)
  其中 m 和 n 是矩阵的行数和列数；
  需要遍历整个矩阵寻找每个 1，遍历矩阵的时间复杂度是 O(mn)；
  对于每个可能的正方形，其边长不超过 m 和 n 中的最小值，需要遍历该正方形中的每个元素判断是不是只包含 1，遍历正方形时间复杂度是 O(min(m,n)²)；
  总时间复杂度是 O(mnmin(m,n)²)。

• 空间复杂度：O(1)
  额外使用的空间复杂度为常数。

动态规划

利用动态数组存储目前最大正方形，dp(i,j) 由其上方、左方和左上方的三个相邻位置的 dp 值决定。

• 时间复杂度：O(mn)
  其中 m 和 n 是矩阵的行数和列数，遍历原始矩阵中的每个元素计算 dp 的值。

• 空间复杂度：O(mn)
  其中 m 和 n 是矩阵的行数和列数。创建了一个和原始矩阵大小相同的矩阵 dp。

提交代码

暴力法

class Solution:
    def maximalSquare(self, matrix: List[List[str]]) -> int:
        if len(matrix) == 0 or len(matrix[0]) == 0:
            return 0
        
        maxSide = 0
        rows, columns = len(matrix), len(matrix[0])
        for i in range(rows):
            for j in range(columns):
                if matrix[i][j] == '1':
                    # 遇到一个 1 作为正方形的左上角
                    maxSide = max(maxSide, 1)
                    # 计算可能的最大正方形边长
                    currentMaxSide = min(rows - i, columns - j)
                    for k in range(1, currentMaxSide):
                        # 判断新增的一行一列是否均为 1
                        flag = True
                        if matrix[i + k][j + k] == '0':
                            break
                        for m in range(k):
                            if matrix[i + k][j + m] == '0' or matrix[i + m][j + k] == '0':
                                flag = False
                                break
                        if flag:
                            maxSide = max(maxSide, k + 1)
                        else:
                            break
        
        maxSquare = maxSide * maxSide
        return maxSquare

# https://leetcode-cn.com/problems/maximal-square/solution/zui-da-zheng-fang-xing-by-leetcode-solution/

动态规划

class Solution:
    def maximalSquare(self, matrix: List[List[str]]) -> int:
        if len(matrix) == 0 or len(matrix[0]) == 0:
            return 0
        
        maxSide = 0
        rows, columns = len(matrix), len(matrix[0])
        dp = [[0] * columns for _ in range(rows)]
        for i in range(rows):
            for j in range(columns):
                if matrix[i][j] == '1':
                    if i == 0 or j == 0:
                        dp[i][j] = 1
                    else:
                        dp[i][j] = min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1
                    maxSide = max(maxSide, dp[i][j])
        
        maxSquare = maxSide * maxSide
        return maxSquare

# https://leetcode-cn.com/problems/maximal-square/solution/zui-da-zheng-fang-xing-by-leetcode-solution/

总结

1. 在确定正方形左上角后，对新增元素的方向判断考虑不周，不是每行每列的判断奏效，从左上角扩展的角度，左上角至右下角，于是新增下一行与右边一列来判断是否是最大正方形；
2. 动态转移方程 dp(i,j) 写了比较长时间，dp 值影响着最后的结果。