leetcode221.最大正方形

题目来源：题目

题目

在一个由 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’的元素，计算以它为正方形左上角元素的最大正方形面积。

首先要知道以该元素为正方形左上角的边长最大值，正方形的长和宽不能超过矩形的行数和列数。

每当计算出一个正方形时，给他的行和列都添加一行，判断是否构成正方形。如果可以构成，继续添加行和列，否则遍历下一个元素。

思路二（动态规划）

       用matrix表示矩阵

       用dp[i][j]表示从以i，j为下标的矩阵中存在的最大正方形的边长。

       如果matrix[0][0]为1，则dp[i][j]=1，否则dp[i][j]=0;

       接着遍历剩余的矩阵元素。matrix[i][j]子矩阵可以存在的最大正方形的边长为min(i,j)+1.

Matrix[i][j-1]和maxtrix[i-1][j]子矩阵中可以存在的最大正方形边长分别为min(I,j-1)+1和min(i-1,j)+1.

       如果min(I,j)等于min(I,j-1)

如果dp[I][j-1]存在最大正方形边长时，dp[i][j]=dp[i][j-1]

否则dp[i][j-1]中不存在正方形边长最大值时，判断以matrix[i][j]为右下角的正方形的边长是否为dp[i][j-1]+1.如果存在，则dp[i][j]=dp[i][j-1]+1.则dp[i][j]=dp[i][j-1]

       如果min(I,j)大于min(I,j-1)时

判断以matrix[i][j]为右下角的正方形边长是否为dp[i][j-1]+1.如果存在，则dp[i][j]=dp[i][j-1]+1.则dp[i][j]=dp[i][j-1]

       还要用上述的方法判断dp[i][j]与dp[i-1][j]的关系，取计算的dp[i][j]的最大值。

最后计算到dp[m-1][n-1]，即为题目给出的矩阵的最大正方形边长。

最后返回dp[m-1][n-1]* dp[m-1][n-1]

代码

动态规划代码

public static int maximalSquare(char[][] matrixmatrix) {
    if(matrix == null || matrix.length == 0)return 0;
    int m = matrix.length,n = matrix[0].length;
    int dp[][] = new int[m][n];
    if(matrix[0][0] == '1')dp[0][0] = 1;
    else dp[0][0] = 0;
    for(int i = 0; i < m; i++){
        for(int j = 0; j < n;j++){
            System.out.println(m + " " + n);
            if(i == 0 && j == 0)continue;
            int dp1 = 0,dp2 = 0;
            if(i - 1 >= 0){
                //System.out.println("come");
                if(Math.min(i,j) == Math.min(i - 1,j)){
                    if(dp[i - 1][j] == Math.min(i,j) + 1)dp1 = dp[i - 1][j];
                    else {
                        if(isCur(matrix,i,j,dp[i - 1][j] + 1))dp1 = dp[i - 1][j] + 1;
                        else dp1 = dp[i - 1][j];
                    }
                }else {
                    if(isCur(matrix,i,j,dp[i-1][j] + 1))dp1 = dp[i - 1][j] + 1;
                    else dp1 = dp[i - 1][j];
                }
            }
            if(j - 1 >= 0){
                //System.out.println("come");
                if(Math.min(i,j) == Math.min(i,j - 1)){
                    if(dp[i][j - 1] == Math.min(i,j) + 1)dp2 = dp[i][j - 1];
                    else {
                        //System.out.println("come");
                        if(isCur(matrix,i,j,dp[i][j - 1] + 1))dp2 = dp[i][j - 1] + 1;
                        else dp2 = dp[i][j - 1];
                    }
                }else {
                    if(isCur(matrix,i,j,dp[i][j - 1] + 1))dp2 = dp[i][j - 1] + 1;
                    else dp2 = dp[i][j - 1];
                }
            }
            dp[i][j] = Math.max(dp1,dp2);
        }
    }
    //System.out.println(dp[0][1]);
    return dp[m - 1][n - 1] * dp[m - 1][n - 1];
}
public static boolean isCur(char[][] matrix,int i,int j,int len){
    for(int m = i;m > i - len;m--){
        for(int n = j;n > j - len;n--){
            if(matrix[m][n] == '0')return false;
        }
    }
    return true;
}

总结

1.暴力搜索的时间复杂度为O(mnMin(m,n)^2),其中m,n分别为矩阵的行数和列数

因为矩阵中的每个‘1’都要遍历，时间复杂度为O(mn)

对于每个‘1’都要找边长最大的正方形，该过程的时间复杂度为O(min(m,n)^2)

空间复杂度为O(1)

2动态规划的时间复杂度为O(mn),只需要计算每个子矩阵的dp值即可。

空间复杂度为O(mn).