最大正方形

最大正方形题解

1.问题描述

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

注意：二维矩阵不一定是正方形。

示例 1：

在这里插入图片描述
在这里插入图片描述

输入：matrix = [[“0”,“1”],[“1”,“0”]]
输出：1

示例 2：

在这里插入图片描述
在这里插入图片描述

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

示例 3：
输入：matrix = [[“0”]]
输出：0

2.思路

暴力求解思想非常朴素：

遍历矩阵，遇到 1 则作为最大正方形的左上角；
根据左上角所在的行和列计算可能的最大正方形；
在可能的最大正方形内，每次循环在下方一行和右方一列验证是否所有元素都是 1。
4.1.2 复杂度分析
时间复杂度
为

，其中 m 和 n 分别是矩阵的行数与列数。

需要遍历整个矩阵寻找每个 1，遍历矩阵的时间复杂度是 O(mn)。

对于每个可能的正方形，其边长不超过 m 和 n 中的最小值，需要遍历该正方形中的每个元素判断是不是只包含 1，遍历正方形时间复杂度是

所以总时间复杂度是

空间复杂度
为 O(1)，因为没有用到额外的空间来存储矩阵元素，所以空间复杂度为常数级。

不过这个一般不是面试官想要的答案。

3. 动态规划

暴力法虽然直观易于理解，但是时间复杂度太高，有没有办法降低时间复杂度呢？

暴力求解过程中，我们可以发现，在遍历每一个可能的最大正方形时，存在着很多重复的计算，因此我们可以使用动态规划来记录每一步骤中的中间结果，来减少重复的计算。

因此可以使用动态规划降低时间复杂度。我们用 dp(i, j) 表示以 (i, j) 为右下角，且只包含 1 的正方形的边长最大值。如果我们能计算出所有 dp(i,j) 的值，那么其中的最大值的平方即为题解。

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

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

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

此外，还需要考虑边界条件。如果 i 和 j 中至少有一个为 0，则以位置 (i,j) 为右下角的最大正方形的边长只能是 1，因此 dp(i, j) = 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

对应的 dp 值如下。

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

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

3.1. 复杂度分析

时间复杂度
O(mn)，其中 m 和 n 是矩阵的行数和列数。遍历完矩阵便可求出全为 1 的最大正方形面积。

空间复杂度
O(mn)，其中 m 和 n 是矩阵的行数和列数。因为要记录每一个位置的最大正方形边长，所以需要 mn 个额外空间。

4.实现示例

下面以动态规划为例给出实现示例。

4.1 C++

#include <algorithm>

// maximalSquare 最大正方形面积。
int maximalSquare(vector<vector<char>> &matrix) {
  // 矩阵的行数和列数。
  int rows = matrix.size(), columns = matrix[0].size();

  // 每个位置作为右下角构成全 1 最大正方形边长。
  vector<vector<int>> dp(rows, vector<int>(columns));

  // 全 1 最大正方形边长。
  int maxSide = 0;

  // 遍历矩阵。
  for (int i = 0; i < rows; i++) {
    for (int j = 0; j < columns; j++) {
      // 为 0 则无法构成全 1 正方形。
      if (matrix[i][j] == '0') {
        continue;
      }
      // 处理边界条件。
      if (i == 0 || j == 0) {
        dp[i][j] = 1;
      } else {
        // 根据状态转移方程计算出下一个位置作为右下角构成全 1 最大正方形边长。
        dp[i][j] = min(dp[i - 1][j - 1], min(dp[i][j - 1], dp[i - 1][j])) + 1;
      }
      maxSide = max(maxSide, dp[i][j]);
    }
  }
  return maxSide * maxSide;
}

4.2 Golang

import "math"

// maximalSquare 全 1 最大正方形面积。
func maximalSquare(matrix [][]byte) int {
  // 矩阵的行数和列数。
  rows, columns := len(matrix), len(matrix[0])
  
  // 每个位置作为右下角构成全 1 最大正方形边长。
  var dp [][]int
  for i := 0; i < rows; i++ {
    dp = append(dp, make([]int, columns))
  }
  
  // 全 1 最大正方形边长。
  var maxSide int

  // 遍历矩阵。
  for i := range matrix {
    for j := range matrix[i] {
      // 为 0 则无法构成全 1 正方形。
      if matrix[i][j] == '0' {
        continue
      }
      // 处理边界条件。
      if i == 0 || j == 0 {
        dp[i][j] = 1
      } else {
      	// 根据状态转移方程计算出下一个位置作为右下角构成全 1 最大正方形边长。
      	left, above, leftAbove := dp[i][j-1], dp[i-1][j], dp[i-1][j-1]
      	dp[i][j] = int(math.Min(math.Min(float64(left), float64(above)), float64(leftAbove))) + 1
      }
      if dp[i][j] > maxSide {
        maxSide = dp[i][j]
      }
    }
  }
  return maxSide*maxSide
}