leetcode#221-最大正方形-基本想不出来[蠢]

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        int max_side=0;
        if(matrix.empty()||matrix.size()==0||matrix[0].size()==0)
            return max_side;
        int m = matrix.size();
        int n = matrix[0].size();
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(matrix[i][j]=='1')
                {//以当前i，j为正方形左上角，找一个最长的连续1的横边，和一个最长的连续1的竖边，取较小的那个作为最大边
                    int cur_side = 1;
                    int max_add = min(m-i,n-j);//最长的可加长度
                    for(int k=1;k<max_add;k++){
                        //判断i+k行的，所有j到j+k是否都为1；
                        //判断j+k列的，所有i到i+k是否都为1;
                        bool flag = true;
                        for(int x=j;x<=j+k;x++){
                            if(matrix[i+k][x]=='1') flag = true;
                            else {flag=false;break;}
                        }
                        if(flag){
                            for(int x=i;x<=i+k;x++){
                                if(matrix[x][j+k]=='1') flag=true;
                                else{flag=false;break;}
                            }
                        }
                        if(flag) cur_side+=1;
                            else break;
                    }
                    max_side = max(max_side,cur_side);
                }
            }
        }
        return max_side*max_side;
    }
};

如果遇到这题，八成是要挂了，最麻烦的方法如上，遍历矩阵中每一个点i,j，以其作为正方形的左上角，查找最大的连续正方形，行上后面可加长度是m-i-1，列后面可加长度是n-j-1，因为是正方形，所以整体可加长度就是行列中可加长度取min，循环中k的条件是小于max_add,所以，max_add = min(m-i,n-j);然后遍历的时候，相当于每次k增1时候，都判断新加那一行那一列是不是全为1，如果是cur_side就要增1，不是那么跳出k循环，说明后面再加也不是连续的了。

动态规划解法：

dp[i][j]表示以matrix[i][j]为正方形右下角，最大的正方形，如果matrix[i][j]=0，显然长度为0；如果matrix[i][j]=1,dp[i][j]=min{dp[i-1][j],dp[i][j-1],dp[i-1][j-1]}+1；证明见leetcode官方证明。初始化条件，当i=0或者j=0时，如果matrix[i][j]=1，那么dp[i][j]=1,否则dp[i][j]=0。

 

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        int max_side=0;
        if(matrix.empty()||matrix.size()==0||matrix[0].size()==0)
            return max_side;
        vector<vector<int>> dp(matrix.size(),vector<int>(matrix[0].size(),0));
        for(int i = 0;i<matrix.size();i++){
            for(int j=0;j<matrix[0].size();j++){
                if(matrix[i][j]=='0') {dp[i][j]=0; continue;}
                if(i==0||j==0) {dp[i][j]=1; max_side = max(max_side,dp[i][j]);}
                else{
                    dp[i][j]=min(dp[i-1][j],min(dp[i][j-1],dp[i-1][j-1]))+1;
                    if(dp[i][j]>max_side) max_side = dp[i][j];
                }
            }
        }
        return max_side*max_side;
    }
};