[LeetCode] 每日打卡 221. 最大正方形

221. 最大正方形

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

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

示例:

输入:

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

输出: 4

解答

我自己的垃圾算法。鬼知道怎么想到的，我的状态转移方程没找到。

class Solution:

    def isSqure(self, y, x, n, matrix):
        # 判断是否会超出边界
        if y + n - 1 > len(matrix) - 1:
            return False
        elif x + n - 1 > len(matrix[y]) - 1:
            return False
        elif matrix[y+n-1][x+n-1] != "1":
            return False

        for i in range(1, n+1):
            if matrix[y+n-1][x+i-1] != "1":
                return False

        for i in range(1, n+1):
            if matrix[y+i-1][x+n-1] != "1":
                return False

        return True

    def maximalSquare(self, matrix) -> int:
        # 动态规划，存放各种长度的点集
        # dp[n] ->n 代表正方形长度
        dp = []
        # 初始化
        for idy, line in enumerate(matrix):
            for idx, value in enumerate(line):
                if value == "1":
                    if len(dp) == 0:
                        dp = [[], []]
                    dp[1].append((idy, idx))

        for n, vector_list in enumerate(dp):
            for vector in vector_list:
                idy, idx = vector
                if self.isSqure(idy, idx, n+1, matrix):
                    if len(dp) == n + 1:
                        dp.append([])
                    dp[n+1].append((idy, idx))

        n = len(dp)
        return max(0, n-1)**2

1. 找到一个状态转移方程
   首先最大正方形就是左上到右下两个点，我选的是左上，但是我的顺序还是从左上往下，没有跳脱出来还是相当于乖乖遍历。如果使用右下点，同时顺序还是左上往右下则可以在遍历的同时利用先前的结果因为这个点是不是一个正方形的右下点只要上、左上、左都是1即可，然后这个点所在最大正方形边长就是这周围三个点所在最大正方形的边长中最小+1，因为这4个点已经组成一个正方形，最大边长就在于那3个点共同能向外延展的长度。
2. dp[i][j] = min(dp[i][j-1], dp[i-1][j], dp[i-1][j-1])
3. 写代码
4. 反省中。

int min(int a, int b){
    
    
    return a < b ? a : b;
}

int max(int a, int b){
    
    
    return a > b ? a : b;
}

int maximalSquare(char** matrix, int matrixSize, int* matrixColSize) {
    
    
    if (matrixSize == 0 || matrixColSize[0] == 0) {
    
    
        return 0;
    }
    int maxSide = 0;
    int rows = matrixSize;
    int columns = matrixColSize[0];
    int dp[rows][columns];
    for (int i = 0; i < rows; i++) {
    
    
        for (int j = 0; j < columns; j++) {
    
    
            if (matrix[i][j] == '1') {
    
    
                if (i == 0 || j == 0) {
    
    
                    // 因为处于边界上，左、左上、上三个中最小为0
                    dp[i][j] = 1;
                } else {
    
    
                    dp[i][j] = min(min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]) + 1;
                }
                maxSide = max(maxSide, dp[i][j]);
            }else{
    
    
                dp[i][j] = 0;	// 记得初始化
            }
        }
    }
    return maxSide * maxSide;