Leetcode之最大黑方阵

题目：

给定一个方阵，其中每个单元(像素)非黑即白。设计一个算法，找出 4 条边皆为黑色像素的最大子方阵。

返回一个数组 [r, c, size] ，其中 r, c 分别代表子方阵左上角的行号和列号，size 是子方阵的边长。若有多个满足条件的子方阵，返回 r 最小的，若 r 相同，返回 c 最小的子方阵。若无满足条件的子方阵，返回空数组。

示例 1:

输入:
[
   [1,0,1],
   [0,0,1],
   [0,0,1]
]
输出: [1,0,2]
解释: 输入中 0 代表黑色，1 代表白色，标粗的元素即为满足条件的最大子方阵
示例 2:

输入:
[
   [0,1,1],
   [1,0,1],
   [1,1,0]
]
输出: [0,0,1]
提示：

matrix.length == matrix[0].length <= 200

代码：

方法一——通过计算每一行每一列的sum，结合判断语句求解：

class Solution {
public:
    vector<int> findSquare(vector<vector<int>>& matrix) {
int len=matrix.size();
    vector<vector<int>> rowsum(len,vector<int>(len,0));
    vector<vector<int>> colsum(len,vector<int>(len,0));
    int ress=0,resr=0,resc=0;
    for(int i=0;i<len;i++){
        for(int j=0;j<len;j++){
            rowsum[i][j]=j==0?matrix[i][j]:matrix[i][j]+rowsum[i][j-1];
            colsum[j][i]=i==0?matrix[i][j]:matrix[i][j]+colsum[j][i-1];
        }
    }
    for(int s=1;s<=len;s++){
        for(int r=0;r<len-s+1;r++){
            for(int c=0;c<len-s+1;c++){
                int dr=r+s-1,dc=c+s-1;
                if(rowsum[r][dc]-rowsum[r][c]+matrix[r][c]==0
                &&rowsum[dr][dc]-rowsum[dr][c]+matrix[dr][c]==0
                &&colsum[c][dr]-colsum[c][r]+matrix[r][c]==0
                &&colsum[dc][dr]-colsum[dc][r]+matrix[r][dc]==0){
                    if(s>ress){
                        ress=s;
                        resr=r;
                        resc=c;
                    }
                }
            }
        }
    }
    if(ress==0)return {};
    return {resr,resc,ress};
    }
};

想法：

抓住题目核心，是方阵，即长和宽相等，那么可以用类似于括号那种三重循环了；然后注意需要判断四个边是否是黑色，那么可以事先计算行、列元素的和，存在数组中以节省时间； 

方法二——：

class Solution {
public:
    vector<int> findSquare(vector<vector<int>>& matrix) {
        vector<int> ans(3, 0);
        int n = matrix.size();
        if(n == 0) return {};
        if(n == 1){
            if(matrix[0][0] == 0)
                return {0, 0, 1};
            else
                return {};
        }
        //cnt[r][c][0/1],0右侧,1下侧
        vector<vector<vector<int>>> cnt(n, vector<vector<int>>(n, vector<int>(2)));
        for(int r = n-1; r >= 0; r--){
            for(int c = n-1; c >= 0; c--){
                if(matrix[r][c] == 1)
                    cnt[r][c][0] = cnt[r][c][1] = 0;
                else{
                    //统计cnt[r][c][0/1]
                    if(r < n-1) cnt[r][c][1] = cnt[r+1][c][1] + 1;
                    else cnt[r][c][1] = 1;

                    if(c < n-1) cnt[r][c][0] = cnt[r][c+1][0] + 1;
                    else cnt[r][c][0] = 1;
				   //更新当前最大子方阵
                    int len = min(cnt[r][c][0], cnt[r][c][1]);//最大的可能的边长
                    while(len >= ans[2]){//要答案r,c最小，所以带等号
                        if(cnt[r+len-1][c][0] >= len && cnt[r][c+len-1][1] >= len){
                            //可以构成长为len的方阵
                            ans = {r, c, len};
                            break;
                        }
                        len--;
                    }
                }
            }
        }
        return ans;
    }
};

想法：使用cnt[r][c][0/1]数组，cnt[r][c][1]表示从第r行第j列的元素向下连续的0的个数，cnt[r][c][0]表示从第r行第j列的元素向右连续的0的个数；这样可以演化成一个动态规划问题，从最后一行，最后一列开始遍历，如果matrix[i][j]==1，那么cnt[r][c][0]=cnt[r][c][1]=0；否则，cnt[r][c][0]=cnt[r][c+1][0]+1,cnt[r][c][1]=cnt[r+1][c][1]+1;取len=min(cnt[r][c][0],cnt[r][c][1])；while(len>=ans[2])判断是否Len满足，更新；遍历结束，得到符合条件的结果。

核心在于考虑矩形的结构，左下的右边，右上的下边；所以需要右边，下边两个维度。