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

方法一：动态规划

如果我们能计算出所有 dp(i,j)\textit{dp}(i, j)dp(i,j) 的值，那么其中的最大值即为矩阵中只包含 111 的正方形的边长最大值，其平方即为最大正方形的面积。

代码如下：

class Solution {
    public int maximalSquare(char[][] matrix) {
    int m = matrix.length,n = matrix[0].length, a = 0;
    int[][] dp = new int[m][n];
    for(int i = 0; i < m;i++)
    {
        for(int j = 0; j < n; j++ )
        {
            if(i == 0 || j == 0)
            {
                dp[i][j] = matrix[i][j] - '0';
            }
            else if (matrix[i][j] == '1')
            {
                dp[i][j] = Math.min(dp[i-1][j-1],Math.min(dp[i][j-1],dp[i-1][j]))+ 1;
            }
            a = Math.max(a,dp[i][j]);
        }
    }       
    return a * a;
    }
}

方法二：暴力求解

        遍历矩阵中的每个元素，每次遇到 1，则将该元素作为正方形的左上角.确定正方形的左上角后，根据左上角所在的行和列计算可能的最大正方形的边长（正方形的范围不能超出矩阵的行数和列数），在该边长范围内寻找只包含 1 的最大正方形。新增下一行或有一行时，判断行中所含元素是否为一。

代码如下：

class Solution {
    public int maximalSquare(char[][] matrix){
        int a = 0,m = matrix.length,n = matrix[0].length ;
        if(matrix == null || m == 0 || n == 0)
        {
            return 0;
        }
        for(int i = 0; i < m;i++)
        {
            for(int j = 0; j < n;j++)
            {
                if(matrix[i][j] == '1')
                {
                    a = Math.max(a,1);
                    int b = Math.min(m-i,n-j);
                    for(int p = 1;p < b; p++)
                    {
                        boolean flag = true;
                        if(matrix[i+p][j+p] == '0')
                        {
                            break;
                        }
                        for(int w = 0; w < p; w++)
                        {
                            if(matrix[i+p][j+w]=='0' || matrix[i+w][j+p]=='0'){
                                flag = false;
                                break;
                            }
                        }
                        if(flag)
                        {
                            a = Math.max(a,p+1);
                        }
                        else
                        {
                            break;
                        }
                    }
                }
            }
        }
         int s = a * a;
    return s;
    }
}

   

方法三：利用矩阵相加（有这个想法但自己没有实现）

我们讨论从第i（0<i<M）行到第j行(i<j<M)的纵向累加和数组，什么叫纵向累加和，举个例子，如果矩阵是：
1 2 4 -1
0 3 -2 5
4 -4 1 -1
那么从第0行到第2行的纵向累加和为：5 1 3 3。把所有的纵向累加数组枚举出来（需要O(M^2)的时间复杂度），然后讨论在这个数组中值为 j-i+1连续出现的最大长度（len），这个就可以直接用动态规划或者贪心思想。我们要求的正方行的边长（ans_len）即为len和 j-i+1的较小值，并将最大ans_len记录下来。

代码如下：

  public int maximalSquare(char[][] matrix) {
        int M=matrix.length;
        int N=matrix[0].length;
        int ans_len=0,len=0;
        int[] high=null;//纵向累加数组
        for(int i=0;i<M;i++){
            high=new int[N];
            for(int j=i;j<M;j++){
                len=0;//start=0;
                for(int k=0;k<N;k++){
                    high[k]+=matrix[j][k]-'0';
                    if(high[k]==j-i+1){
                        len++;
                        ans_len=Math.max(ans_len,Math.min(len,high[k]));
                    }else len=0;//start=k+1; 
                }
            }
        }
        return ans_len*ans_len;
    }
}