LeetCode 221. 最大正方形

dreamer'~

已于 2023-05-02 19:40:33 修改

阅读量416

点赞数

文章标签： leetcode 动态规划

于 2022-12-26 19:27:21 首次发布

本文链接：https://blog.csdn.net/qq_37102984/article/details/128448328

版权

LeetCode 专栏收录该内容

176 篇文章 5 订阅

订阅专栏

LeetCode 221. 最大正方形

在一个由 '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 视频题解并加以修改：LeetCode官方视频题解

若某个格子值为 ‘1’，则在以此格为右下角的正方形中，其最大边长为：上方正方形、左方正方形、左上方正方形中最小的那条边长，最后再加上右下角格子本身的边长 1。
因此可得递推公式：dp[i][j] = 以坐标点(i,j) 为【右下角】的正方形最大边长 = min(左, 上, 左上) + 1
可参考下图：

注意：

最大正方形的边长并不一定是以 matrix二维数组右下角的网格参与构成的，而是在遍历过程中不断比较并随时记录到 maxLen 变量中的。因此，最后返回的结果不是 dp[m][n] * dp[m][n]，而是 maxLen * maxLen。

时间复杂度：O(mn)，其中 m 和 n 是矩阵的行数和列数

空间复杂度：O(mn)，其中 m 和 n 是矩阵的行数和列数

// 参考 LeetCode 视频题解：https://leetcode.cn/problems/maximal-square/solutions/234964/zui-da-zheng-fang-xing-by-leetcode-solution/
// 思路：以坐标点(i,j) 为【右下角】的正方形最大边长 = min(左, 上, 左上) + 1。+1：右下角的格子本身
// 注意在递推方程中：d[i][j] 代表的是 以坐标点(i,j) 为【右下角】的正方形最大边长

// 注意：
// 最大正方形的边长 并不一定是以 matrix二维数组 右下角的网格参与构成的，
// 而是在遍历过程中不断比较并随时记录到 maxLen 变量中的。
// 因此，最后返回的结果不是 dp[m][n] * dp[m][n]，而是 maxLen * maxLen。
func maximalSquare(matrix [][]byte) int {
    m, n, maxVal := len(matrix), len(matrix[0]), 0
    dp := make([][]int, m + 1)
    for i := 0; i <= m; i++ {
        dp[i] = make([]int, n + 1)
    }

    for i := 1; i <= m; i++ {
        for j := 1; j <= n; j++ {
            if matrix[i-1][j-1] == '1' {
                // 以坐标点(i,j) 为【右下角】的正方形最大边长 = min(左, 上, 左上) + 1
                // +1：右下角的格子本身
                dp[i][j] = min(dp[i][j-1], dp[i-1][j], dp[i-1][j-1]) + 1
            }
            // if matrix[i-1][j-1] == '0'时，跳过不处理

            if maxVal < dp[i][j] {
                maxVal = dp[i][j]
            }
        }
    }

    return maxVal*maxVal
}

func min(vals ... int) int {
    minVal := vals[0]
    for _, val := range vals {
        if val < minVal {
            minVal = val
        } 
    }
    return minVal
}

// func min(left, up, leftUp int) int {
//     arr := []int{left, up, leftUp}
//     sort.Ints(arr)
//     return arr[0]
// }

// func maximalSquare(matrix [][]byte) int {
//     m, n, maxLen := len(matrix), len(matrix[0]), 0
    
//     // init dp array
//     dp := make([][]int, m)
//     for i := 0; i < m; i++ {
//         dp[i] = make([]int, n)
//     }

//     for i := 0; i < m; i++ {
//         for j := 0; j < n; j++ {
//             if matrix[i][j] == '1' {
//                 // 边界条件处理：自身格子为'1'，且位于 第0行/第0列 的dp数组初始化为1
//                 if i == 0 || j == 0 {
//                     dp[i][j] = 1
//                 } else {
//                     // 以坐标点(i,j) 为【右下角】的正方形最大边长 = min(左, 上, 左上) + 1
//                     dp[i][j] = min(dp[i][j-1], dp[i-1][j], dp[i-1][j-1]) + 1 // +1：右下角的格子本身
//                 }

//                 if maxLen < dp[i][j] {
//                     maxLen = dp[i][j]
//                 }
//             }
//         }
//     }

//     return maxLen*maxLen
// }

另外附上：自己在LeetCode上写的题解：我的题解