最大正方形

​​https://leetcode-cn.com/problems/maximal-square/​​

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

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

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

**输入：**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的矩形里面最大的正方有多大。那么这道题目，仔细分析一下，会发现，其实和求最大连续和和最大连续乘积类似，都是算不算自己的问题。也就是说，只需要比较dp[i-1][j]、dp[i][j-1]和包含自己在内的最大正方形的大小，就可以得到dp[i][j]的最值。

代码如下：

class Solution {
    public int maximalSquare(char[][] matrix) {
        int n = matrix.length;
        int m = matrix[0].length;
        int[][] dp = new int[n + 2][m + 2];
        boolean[][][] tmp = new boolean[n + 2][m + 2][m + 2];
        int ans = -1;
        for (int i = 0; i < n; i++) {
            dp[i][0] = Integer.parseInt(matrix[i][0] + "");
            ans = Math.max(ans, dp[i][0]);
        }
        for (int i = 0; i < m; i++) {
            dp[0][i] = Integer.parseInt(matrix[0][i] + "");
            ans = Math.max(ans, dp[0][i]);
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                for (int k = j; k >= 0; k--) {
                    if (matrix[i][k] == '0') {
                        tmp[i][k][j] = false;
                    } else {
                        if (k == j) {
                            tmp[i][k][j] = true;
                        } else {
                            tmp[i][k][j] = tmp[i][k + 1][j];
                        }
                    }
                }
            }
        }
        for (int i = 1; i < n; i++) {
            for (int j = 1; j < m; j++) {
                if (matrix[i][j] == '0') {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                } else {
                    // TODO: 2022/4/28 获取以当前节点为右下端点的最大正方形
                    int cntJ = 0;
                    int cntI = 0;
                    for (int k = j; k >= 0; k--) {
                        if (matrix[i][k] == '1') {
                            cntJ++;
                        } else {
                            break;
                        }
                    }
                    for (int k = i; k >= 0; k--) {
                        if (matrix[k][j] == '1') {
                            cntI++;
                        } else {
                            break;
                        }
                    }
                    int bian = Math.min(cntI, cntJ);
                    for (int tmpBian = bian; tmpBian >= 1; tmpBian--) {
                        int beginI = i - tmpBian + 1;
                        int beginK = j - tmpBian + 1;
                        int flag = 0;
                        int containMeAns = -1;
                        for (int k = beginI; k <= i; k++) {
                            if (!tmp[k][beginK][j]) {
                                flag = 1;
                                break;
                            }
                        }

                        if (flag == 0) {
                            containMeAns = tmpBian * tmpBian;
                            dp[i][j] = Math.max(containMeAns, Math.max(dp[i - 1][j], dp[i][j - 1]));
                            break;
                        }
                    }
                }
                ans = Math.max(dp[i][j], ans);
            }
        }
        return ans;
    }
}