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'

二、解题思路

这个问题可以使用动态规划的方法来解决。我们可以定义一个二维数组 dp，其中 dp[i][j] 表示以 (i, j) 为右下角的最大正方形的边长。状态转移方程如下：

• 如果 matrix[i][j] == '0'，则 dp[i][j] = 0；
• 如果 matrix[i][j] == '1'，则 dp[i][j] = Math.min(Math.min(dp[i-1][j], dp[i][j-1]), dp[i-1][j-1]) + 1。

我们从左上角开始遍历整个矩阵，并更新 dp 数组。在遍历的过程中，我们可以用一个变量 maxSide 来记录遇到的最大正方形的边长。最后，返回 maxSide * maxSide 即为最大正方形的面积。

三、具体代码

class Solution {
    public int maximalSquare(char[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        int maxSide = 0;
        int[][] dp = new int[m][n];

        // 遍历矩阵
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                // 如果当前元素是 '1'
                if (matrix[i][j] == '1') {
                    // 如果是第一行或第一列，则只能形成边长为1的正方形
                    if (i == 0 || j == 0) {
                        dp[i][j] = 1;
                    } else {
                        // 根据状态转移方程计算 dp[i][j]
                        dp[i][j] = Math.min(Math.min(dp[i-1][j], dp[i][j-1]), dp[i-1][j-1]) + 1;
                    }
                    // 更新最大边长
                    maxSide = Math.max(maxSide, dp[i][j]);
                }
            }
        }
        // 返回最大正方形的面积
        return maxSide * maxSide;
    }
}

这段代码首先初始化 dp 数组和 maxSide 变量，然后遍历矩阵的每个元素，根据状态转移方程更新 dp 数组，并记录下遇到的最大正方形的边长。最后返回最大正方形的面积。

四、时间复杂度和空间复杂度

1. 时间复杂度

• 我们需要遍历整个二维矩阵，矩阵的大小为 m * n，其中 m 是矩阵的行数，n 是矩阵的列数。
• 在遍历过程中，对于每个元素 (i, j)，我们进行常数时间的操作，包括判断元素是否为 '1'，以及更新 dp[i][j] 的值。
• 因此，整个算法的时间复杂度为 O(m * n)，即我们需要遍历矩阵中的每个元素一次。

2. 空间复杂度

• 我们使用了一个额外的二维数组 dp 来存储以每个元素 (i, j) 为右下角的最大正方形的边长，dp 的大小与输入矩阵相同，为 m * n。
• 除了输入矩阵外，我们只使用了常数额外空间（maxSide 变量）。
• 因此，算法的空间复杂度为 O(m * n)，即我们使用的额外空间与输入矩阵的大小成线性关系。

五、总结知识点

1. 二维数组的使用：代码中定义了一个二维数组 dp，用于动态规划存储每个位置 (i, j) 为右下角的最大正方形的边长。

2. 动态规划：动态规划是一种算法设计技术，用于求解最优化问题。在这个问题中，通过构建一个二维数组 dp，并基于状态转移方程来逐步求解子问题。

3. 状态转移方程：状态转移方程 dp[i][j] = Math.min(Math.min(dp[i-1][j], dp[i][j-1]), dp[i-1][j-1]) + 1 用于确定当前位置 (i, j) 为右下角的最大正方形的边长。

4. 边界条件处理：在二维数组 dp 中，第一行和第一列的元素需要特殊处理，因为它们没有上方或左边的元素，所以只能形成边长为1的正方形。

5. 字符串与字符数组：代码处理的是字符数组 char[][] matrix，其中每个元素是字符 ‘0’ 或 ‘1’。

6. 嵌套循环：使用了嵌套循环来遍历二维数组，外层循环遍历行，内层循环遍历列。

7. 条件判断：使用了 if 语句来检查当前元素是否为 ‘1’，以及是否位于第一行或第一列。

8. 数学函数：使用了 Math.min 函数来计算三个数中的最小值，以及 Math.max 函数来更新最大边长。

9. 算法优化：代码在遍历过程中实时更新最大边长 maxSide，避免了最后再次遍历 dp 数组来找出最大值。

10. 问题转化：将寻找最大正方形的问题转化为计算每个位置的最大正方形边长的问题，然后通过比较得到最大值。

以上就是解决这个问题的详细步骤，希望能够为各位提供启发和帮助。