leetcode-221最大正方形问题

问题描述

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

示例:

输入: 

1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 0 0 1 0

输出: 4

解题思路

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/maximal-square/solution/zui-da-zheng-fang-xing-by-leetcode-solution/
来源：力扣（LeetCode）

方法一：暴力法

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

暴力法是最简单直观的做法，具体做法如下：

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

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

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

复杂度分析

时间复杂度：其中 m 和 n 是矩阵的行数和列数。

• 需要遍历整个矩阵寻找每个 1，遍历矩阵的时间复杂度是 。
• 对于每个可能的正方形，其边长不超过 m 和 n 中的最小值，需要遍历该正方形中的每个元素判断是不是只包含 1，遍历正方形时间复杂度是 。
• 总时间复杂度是。
  空间复杂度：。额外使用的空间复杂度为常数。

方法二：动态规划

方法一虽然直观，但是时间复杂度太高，有没有办法降低时间复杂度呢？

可以使用动态规划降低时间复杂度。我们用 表示以 为右下角，且只包含 1的正方形的边长最大值。如果我们能计算出所有 的值，那么其中的最大值即为矩阵中只包含 1 的正方形的边长最大值，其平方即为最大正方形的面积。

那么如何计算 中的每个元素值呢？对于每个位置 ，检查在矩阵中该位置的值：

如果该位置的值是 0，则 ，因为当前位置不可能在由 1 组成的正方形中；

如果该位置的值是 1，则 的值由其上方、左方和左上方的三个相邻位置的 值决定。具体而言，当前位置的元素值等于三个相邻位置的元素中的最小值加 1，状态转移方程如下：

如果读者对这个状态转移方程感到不解，可以参考 1277. 统计全为 1 的正方形子矩阵的官方题解，其中给出了详细的证明。

此外，还需要考虑边界条件。如果和中至少有一个为 0，则以位置为右下角的最大正方形的边长只能是 1，因此 。

以下用一个例子具体说明。原始矩阵如下。

0 1 1 1 0
1 1 1 1 0
0 1 1 1 1
0 1 1 1 1
0 0 1 1 1

对应的 值如下。

0 1 1 1 0
1 1 2 2 0
0 1 2 3 1
0 1 2 3 2
0 0 1 2 3

下图也给出了计算 值的过程。

image.png

复杂度分析

时间复杂度：，其中 和 是矩阵的行数和列数。需要遍历原始矩阵中的每个元素计算 的值。

空间复杂度：，其中 和 是矩阵的行数和列数。创建了一个和原始矩阵大小相同的矩阵 。由于状态转移方程中的 由其上方、左方和左上方的三个相邻位置的 值决定，因此可以使用两个一维数组进行状态转移，空间复杂度优化至 。

# 最大正方形问题
import os


class Solution:
    def __init__(self):
        self.matrix = self.loadMatrix()

    def loadDatadet(self, infile):
        f = open(infile, 'r')
        sourceInLine = f.readlines()
        dataset = []
        for line in sourceInLine:
            temp1 = line.strip('\n')
            # 文件中看数字的分隔符是空格还是制表符
            temp2 = temp1.split(' ')
            dataset.append(temp2)
        # for循环转换数据格式str->int
        # for i in range(0, len(dataset)):
        #     k = len(dataset[i])
        #     for j in range(k):
        #         # int转换数字类型
        #         dataset[i].append(int(dataset[i][j]))
        #     del(dataset[i][0:k])
        return dataset

    def loadMatrix(self):
        # 获取当前上层文件夹路径
        current_dir = os.getcwd()
        infile = current_dir+'/5_8_221/data.txt'

        return self.loadDatadet(infile)

    # 暴力法
    def maximalSquare1(self):
        matrix = self.matrix
        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):
                        # flag判断新增的一行是否均为1
                        flag = True
                        # 对角线为零，break
                        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

    def maximalSquare2(self):
        matrix = self.matrix
        if len(matrix) == 0 or len(matrix[0]) == 0:
            return 0
        maxSide = 0
        rows, columns = len(matrix), len(matrix[0])
        # 初始化dp[][]列表解析方法
        dp = [[0]*columns for _ in range(rows)]
        for i in range(rows):
            for j in range(columns):
                if matrix[i][j] == '1':
                    # 判断边界，最上边和最左边的面积最大为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

理解 min(上, 左, 左上) + 1
作者：lzhlyle
链接：https://leetcode-cn.com/problems/maximal-square/solution/li-jie-san-zhe-qu-zui-xiao-1-by-lzhlyle/
来源：力扣（LeetCode）
如题，在其他动态规划方法的题解中，大都会涉及到下列形式的代码：

// 伪代码

if (matrix(i - 1, j - 1) == '1') {
    dp(i, j) = min(dp(i - 1, j), dp(i, j - 1), dp(i - 1, j - 1)) + 1;
}

其中，dp(i, j) 是以 matrix(i - 1, j - 1) 为 右下角 的正方形的最大边长。
等同于：dp(i + 1, j + 1) 是以 matrix(i, j) 为右下角的正方形的最大边长

翻译成中文

若某格子值为 1 ，则以此为右下角的正方形的、最大边长为：上面的正方形、左面的正方形或左上的正方形中，最小的那个，再加上此格

先来阐述简单共识

• 若形成正方形（非单 1），以当前为右下角的视角看，则需要：当前格、上、左、左上都是 1
• 可以换个角度：当前格、上、左、左上都不能受 0 的限制，才能成为正方形

image.png

上面详解了 三者取最小 的含义：

• 图1：受限于左上的0
• 图2：受限于上边的0
• 图3：受限于左边的0
• 数字表示：以此为正方形右下角的最大边长
• 黄色表示：格子 ? 作为右下角的正方形区域
  就像 木桶的短板理论 那样——附近的最小边长，才与? 的最长边长有关。
  此时已可得到递推公式

// 伪代码
if (grid[i - 1][j - 1] == '1') {
    dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1;
}

优化的dp
动态规划的空间复杂度一般都可以进行降维处理，我们看一下自己的递推式，其实只是用到了上一层的 dp[i-1][j-1]和上一层的 dp[i-1][j]，所以我们除了存储一行数据之外，只需要再找一个变量存一下 dp[i-1][j-1]就好了，dp[i-1][j]没必要存，因为更新之前它的值还是旧值。

dp[j] = min(dp[j], min(dp[j - 1], westNorthKey)) + 1;

class Solution:
    def maximalSquare(self, matrix: List[List[str]]) -> int:
       
        if len(matrix) == 0 or len(matrix[0]) == 0:
            return 0

        rows, columns = len(matrix), len(matrix[0])
        # 初始化dp[]列表解析方法
        dp = [0 for _ in range(columns)]
        maxSide = 0
        westNorthKey = 0
        for i in range(rows):
            for j in range(columns):
                #即将更新dp[j]的值，先保存，现在的dp[j]相当于dp[i-1][j],更新后的为dp[i][j]
                # 更新dp[j]即相当于用下一行的数据覆盖上一行
                #temp值保存个循环dp[j+1]，即相当于dp[i][j+1]的左上角的值
                temp = dp[j]
                if matrix[i][j] == '1':
                    # 判断边界，最上边和最左边的面积最大为1
                    if i == 0 or j == 0:
                        dp[j] = 1
                    else:
                        dp[j] = min(dp[j], dp[j-1], westNorthKey)+1
                    maxSide = max(maxSide, dp[j])
                else:
                    dp[j] = 0
                #下一个dp[j+1]的左上角即当前dp[j]的正上方
                westNorthKey = temp

        maxSquare = maxSide*maxSide
        return maxSquare
        

第一个dp[j]代表的是dp[i][j]，第二个dp[j]代表的是dp[i-1][j]，dp[j-1]代表的是dp[i][j-1]，westNorthKey代表的是dp[i-1][j-1]，也就是用新的一行去替换旧的一行的数据。
把每次遍历一维dp[]看成是二维的dp[][]来看，其中temp作用在于保存下一个dp[j+1]的左上角即当前dp[j]的正上方。