【动态规划】力扣221：最大正方形

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

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

方法1：暴力解法
由于正方形的面积等于边长的平方，因此要找到最大正方形的面积，首先需要找到最大正方形的边长，然后计算最大边长的平方即可。
暴力法是最简单直观的做法，具体做法如下：
遍历矩阵中的每个元素，每次遇到 1，则将该元素作为正方形的左上角；
确定正方形的左上角后，根据左上角所在的行和列计算可能的最大正方形的边长（正方形的范围不能超出矩阵的行数和列数），在该边长范围内寻找只包含 1 的最大正方形；
每次在下方新增一行以及在右方新增一列，判断新增的行和列是否满足所有元素都是 1。

方法2：动态规划
可以使用动态规划降低时间复杂度。
用 dp(i,j) 表示以 (i, j) 为右下角，且只包含 1 的正方形的边长最大值。如果能计算出所有 dp(i,j) 的值，那么其中的最大值即为矩阵中只包含 1 的正方形的边长最大值，其平方即为最大正方形的面积。
那么如何计算 dp 中的每个元素值呢？对于每个位置 (i, j)，检查在矩阵中该位置的值：

如果该位置的值是 0，则 dp(i,j)=0，因为当前位置不可能在由 1 组成的正方形中；
如果该位置的值是 1，则 dp(i,j) 的值由其上方dp[i - 1][j]、左方dp[i][j - 1]和左上方dp[i - 1][j - 1] 三个相邻位置的 dp 值决定。具体而言，当前位置的元素值等于三个相邻位置的元素中的最小值加 1，状态转移方程为：dp(i,j) = min(dp(i−1,j),dp(i−1,j−1),dp(i,j−1))+1 。
此外，还需要考虑边界条件。
根据左上角是否为‘1’来为dp矩阵赋值，所以i、j均从1开始。但是这样就有个问题：当i=0或j=0就遗漏了matrix矩阵的右上角和坐下角，因此构建的dp矩阵是一个(m+1)*(n+1)型矩阵。

class Solution:
    def maximalSquare(self, matrix: List[List[str]]) -> int:
        m, n = len(matrix), len(matrix[0])
        if m == 0 or n == 0:
            return 0
        # 注意这里构建的是(m+1)*(n+1)型矩阵
        dp = [[0] * (n + 1) for _ in range(m + 1)] 
        ans = 0
        # 
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if matrix[i - 1][j - 1] == '1':
                    dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1
                if dp[i][j] > ans:
                    ans = dp[i][j]
        return ans * ans

时间复杂度：O(mn)，其中 m 和 n 是矩阵的行数和列数。需要遍历原始矩阵中的每个元素计算 dp 的值。
空间复杂度：O(mn)，其中 m 和 n 是矩阵的行数和列数。创建了一个和原始矩阵大小相同的矩阵 dp。由于状态转移方程中的 dp(i, j) 由其上方、左方和左上方的三个相邻位置的 dp 值决定，因此可以使用两个一维数组进行状态转移，空间复杂度优化至 O(n)。

也可以构建 m * n 的dp矩阵，matrix和dp 一一对应：如果 i 和 j 中至少有一个为 0，则以位置 (i, j) 为右下角的最大正方形的边长只能是 1，因此 dp(i,j)=1 。

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])
        return maxSide * maxSide

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

方法3：二进制
分享一个不用动态规划，采用二进制思路的方法 - 最大正方形 - 力扣（LeetCode）

首先，把矩阵的每一行看作一个二进制数，对于矩阵：
1 0 1 0 0
1 0 1 1 1
两数相与得到
1 0 1 0 0
在这个数字中，连续的 1 就可以看作是正方形的宽，而高度就是 2，因为是 2 个数相与的。要得到正方形，宽和高必须相等，那么就是取宽高中较小的那个作为正方形的边，所以能构成的最大正方形边长为 min(宽,高)=min(1,2)=1。
再来看一个矩阵：
1 0 1 1 1
1 1 1 1 1
相与得到
1 0 1 1 1
连续的 1 有 3 个，所以宽是 3，高仍然是 2，构成的最大正方形边长为 min(宽,高)=min(3,2)=2。

现在我们的任务有 3 个：

把矩阵每一行看作二进制数的表示形式，进而转成数字，得到一个一维数组；
用 2 个指针 i,j 分别表示开始行和最后一行，这2行之间的所有行（包括这 2 行）全部相与，看能得到多少个连续最多的 1，亦即求宽度，而高度则等于 j-i+1。枚举所有的(i,j) 组合，并保存结果中的最大值。
如何求一个数中连续最多的 1？小技巧：每次将这个数和它左移一位后的数相与，直到它变成 0，记录操作次数，这个操作次数就是连续最多的 1。
举个例子：
对于数字 10101010，将这个数和它左移一位后的数相与，操作1次，这个数就变成 0 了，连续最多的 1只有 1 个；
对于数字 10101110，操作 1 次得到 00001100，还需再操作2次才能得到 0，所以连续最多的 1是 3；
相当于每次都错一位相与，所以这个数最多有几个连续的 1，就能错一位相与几次才能得到 0。

class Solution:
    def getWidth(self,num):  #步骤3：求一个数中连续最多的1
        w=0
        while num>0:
            num&=num<<1
            w+=1
        return w
    def maximalSquare(self, matrix: List[List[str]]) -> int:
        nums=[int(''.join(n),base=2) for n in matrix]  #步骤1：每一行当作二进制数
        res,n=0,len(nums)
        for i in range(n):   #步骤2：枚举所有的组合，temp存储相与的结果
            temp=nums[i]
            for j in range(i,n):
                temp&=nums[j]
                w=self.getWidth(temp)
                h=j-i+1
                res=max(res,min(w,h))
        return res*res

作者：Mcdull0921
链接：https://leetcode-cn.com/problems/maximal-square/solution/fen-xiang-yi-ge-bu-yong-dong-tai-gui-hua-cai-yong-/

优化：
当某一行与后面行相与的时候，1 的个数只可能变少，即宽度只会越变越小，当宽度（连续1的个数）小于高度的时候，会以宽度作为正方形的边长，此时高度再增加已经没有意义了，因为不可能再有最大值产生了，所以可以跳出循环，直接开始遍历下一个 start 行：

class Solution:
    def getWidth(self,num):  #步骤3：求一个数中连续最多的1
        w=0
        while num>0:
            num&=num<<1
            w+=1
        return w
    def maximalSquare(self, matrix: List[List[str]]) -> int:
        nums=[int(''.join(n),base=2) for n in matrix]  #步骤1：每一行当作二进制数
        res,n=0,len(nums)
        for i in range(n):   #步骤2：枚举所有的组合，temp存储相与的结果
            temp=nums[i]
            for j in range(i,n):
                temp&=nums[j]
                if self.getWidth(temp)<j-i+1:
                    break
                res=max(res,j-i+1)
        return res*res

作者：Mcdull0921
链接：https://leetcode-cn.com/problems/maximal-square/solution/fen-xiang-yi-ge-bu-yong-dong-tai-gui-hua-cai-yong-/