一天算法（2019-12-13）找到只包含 1 的最大正方形

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

示例:

输入: 

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

输出: 4

分析

• 若形成正方形（非单 1），以当前为右下角的视角看，则需要：当前格、上、左、左上都是 1
• 可以换个角度：当前格、上、左、左上都不能受 0 的限制，才能成为正方形
  
  图片来自
  
  图片来自
• 图1：受限于左上的0
• 图2：受限于上边的0
• 图3：受限于左边的0
• 数字表示：以此为正方形右下角的最大边长
• 黄色表示：格子 ? 作为右下角的正方形区域

就像 木桶的短板理论 那样——附近的最小边长，才与 ? 的最长边长有关。

dp(i, j)=min(dp(i−1, j), dp(i−1, j−1), dp(i, j−1))+1

空间压缩

我们知道计算dp(i, j)只需要用到dp(i−1, j), dp(i−1, j−1), dp(i, j−1)，所以只需要存贮三个变量跟一个一位数组就行了

代码

public static int maximalSquare(char[][] matrix) {
        if (matrix.length == 0) {
            return 0;
        }
        int max = 0;
        int d = 0;
        int[] dp = new int[matrix[0].length];
        for (int j = 0; j < matrix[0].length; j++) {
            dp[j] = Integer.parseInt(String.valueOf(matrix[0][j]));
            if (dp[j] == 1) {
                max = 1;
            }
        }
        for (int i = 1; i < matrix.length; i++) {
            d = dp[0];
            if (d > max) {
                max = d;
            }
            dp[0] = Integer.parseInt(String.valueOf(matrix[i][0]));
            for (int j = 1; j < matrix[0].length; j++) {
                int tem = dp[j];
                if (matrix[i][j] == '1') {
                    dp[j] = Math.min(Math.min(dp[j - 1], dp[j]), d) + 1;
                    if (dp[j] > max) {
                        max = dp[j];
                    }
                }else {
                    dp[j] = 0;
                }
                d = tem;
                System.out.println(max);
            }
        }
        return max * max;
    }

• 时间复杂度：O(mn)。
• 空间复杂度：O(n)，使用了一个一维数组 dp。

其他参考代码

public class Solution {
    public int maximalSquare(char[][] matrix) {
        int rows = matrix.length, cols = rows > 0 ? matrix[0].length : 0;
        int[] dp = new int[cols + 1];
        int maxsqlen = 0, prev = 0;
        for (int i = 1; i <= rows; i++) {
            for (int j = 1; j <= cols; j++) {
                int temp = dp[j];
                if (matrix[i - 1][j - 1] == '1') {
                    dp[j] = Math.min(Math.min(dp[j - 1], prev), dp[j]) + 1;
                    maxsqlen = Math.max(maxsqlen, dp[j]);
                } else {
                    dp[j] = 0;
                }
                prev = temp;
            }
        }
        return maxsqlen * maxsqlen;
    }
}