Given a 2D binary matrix filled with 0's and 1's, find the largest square containing all 1's and return its area.

For example, given the following matrix:

1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 0 0 1 0
Return 4.

思路

性质：当判断以某个点为最大正方形右下角时，那它的上方，左方和左上方三个点也一定是某个正方形的右下角，否则以该点为右下角的正方形最大就是它自己。

那如何求最大正方形边长呢？

1. 若该点为右下角的正方形的最大边长，最多比它的上方，左方和左上方为右下角的正方形的边长多1。
2. 最好的情况是它的上方，左方和左上方为右下角的正方形的大小都一样的，这样加上该点就可以构成一个更大的正方形。
3. 但如果它的上方，左方和左上方为右下角的正方形的大小不一样，合起来就会缺了某个角落，这时候只能取那三个正方形中最小的正方形的边长加1了。假设dpi表示以i,j为右下角的正方形的最大边长，则有

dp[i][j] = min(dp[i-1][j-1], dp[i-1][j], dp[i][j-1]) + 1

当然，如果这个点在原矩阵中本身就是0的话，那dp[i][j]肯定就是0了。

初始化

1. dp[i][0] 为matrix[i][0]
2. dp[0][i] 为matrix[0][i]

计算最长边长

1. global变量记录maxLen
2. 遍历矩阵，如果该点值为1，那么根据状态方程求d[i][j]，同时跟新maxLen
3. 最终，得到maxLen，返回maxLen * maxLen得到面积

public class Solution {
    /*
     * @param matrix: a matrix of 0 and 1
     * @return: an integer
     */
    public int maxSquare(int[][] matrix) {
        // write your code here
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return 0;
        }
        
        //dp[i][j]表示以i,j为右下角的正方形的最大边长
        //dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1
        // 因为如果i,j是如果某个最大正方形的右下角，那么其左，上，左上角的点一定分别是3个正方形的右下角。且dp[i][j]一定是这三者最小边长+1
        
        //1. 初始值，1的边长就是1，0的边长就是0
        int row = matrix.length;
        int col = matrix[0].length;
        int[][] dp = new int[row][col];
        int maxLen = 0;
        
        for (int i = 0; i < row; i++) {
            dp[i][0] = matrix[i][0];
            maxLen = Math.max(maxLen, dp[i][0]);
        }
        
        for (int i = 0; i < col; i++) {
            dp[0][i] = matrix[0][i];
            maxLen = Math.max(maxLen, dp[0][i]);
        }
        
        //2. 遍历计算最大边长
        for (int i = 1; i < row; i++) {
            for (int j = 1; j < col; j++) {
                if (matrix[i][j] == 1) {
                    dp[i][j] = Math.min(dp[i-1][j-1], Math.min(dp[i - 1][j], dp[i][j - 1])) + 1;
                    maxLen = Math.max(maxLen, dp[i][j]);
                }
            }
        }   
        return maxLen * maxLen;
    }
}