leetcode [Dynamic Programming] No.221 Maximal Square

问题描述

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

Example:

Input:

1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 0 0 1 0

Output: 4

解题思路

思路一

我们利用动态规划的思想来解决该题，首先我们构建一个和原矩阵相同大小的二维数组，该数组中第$i$行，第$j$列的元素表示为$b_{i,j}$，原矩阵中第$i$行，第$j$列的元素表示为$a_{i,j}$，则$b_{i,j}$的大小为以$a_{i,j}$为正方形右下角所形成的的最大正方形边长。那么我们有以下推导公式：
$$b_{i,j}=b_{i-1,j-1}+k$$
其中，记x为从$a_{i,j}$到$a_{i-b_{i-1,j-1},j}$最大的全是’1’的子串长度，同理y为从$a_{i,j}$到$a_{i,j-b_{i-1,j-1}}$最大的全是’1’的子串长度，则 k = m i n { x , y , b i − 1 , j − 1 } k=min\{x,y,b_{i-1,j-1}\} k=min{x,y,bi−1,j−1​}。
简单来说就是$b_{i,j}$可以由$b_{i-1,j-1}$得到，我们每次计算$b_{i,j}$的时候，都检查其左上角的$b_{i-1,j-1}$所形成的最大正方形面积，然后检查原正方形的外围一圈有多大的长度都是’1’，然后根据左上角形成的正方形边长加上外围一圈的’1’的长度，即可得到当前位置$b_{i,j}$的大小。

Tips: 测试数据中可能有空的矩阵，所以程序开头需要加一个小判断，不然可能会返回访问空指针的报错。

代码：

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        vector<vector<int>> count;
        if (matrix.size() == 0) return 0;
        int rowSize = matrix.size();
        int colSize = matrix[0].size();
        
        for (int i = 0; i < rowSize; i++) {
            vector<int> sub(colSize);
            count.push_back(sub);
        }
        
        for (int i = 0; i < rowSize; i++) {
            if (matrix[i][0] == '0') count[i][0] = 0;
            else count[i][0] = 1;
        }
        
        for (int i = 0; i < colSize; i++) {
            if (matrix[0][i] == '0') count[0][i] = 0;
            else count[0][i] = 1;
        }
        
        for (int i = 1; i < rowSize; i++) {
            for (int j = 1; j < colSize; j++) {
                if (matrix[i][j] == '0') {
                    count[i][j] = 0;
                    continue;
                }
                int k;
                for (k = 1; k <= count[i-1][j-1]; k++) {
                    if (matrix[i-k][j] == '0' || matrix[i][j-k] == '0') {
                        break;
                    }
                }
              //  cout << "i:" << i << " j:" << j << " k:" << k << endl;
                count[i][j] = k;
            }
        }
        int max = 0;
        for (auto it1 : count) {
            for (auto it2 : it1) {
            //	cout << it2 << " ";
                if (max < it2) max = it2;
            }
          //  cout << endl;
        }
        return max * max;
    }
};

运行结果：

虽然从运行结果来看，该算法还是挺高效的，不过通过分析我们可以得到，带算法的时间效率为$O(n^3)$，因为我们构建了一个二维数组，且在计算该二维数组的每个元素时，都会检查相应的行和列，至于为什么运行这么迅速，可能是测试数据的原因，导致没有达到该算法的最坏效率，实际运行的效率可能为$O(n^2\log n)$。

思路二

该查看了其他人的解题代码之后，我学到了一种更加高效的方法。即我们不需要检查左上角形成正方形的外围一圈，我们可以直接通过以下公式得到$b_{i,j}$的大小，即：
$$b_{i,j}=min(b_{i-1,j},b_{i,j-1},b_{i-1,j-1})$$
事实上，$b_{i-1,j}$就表示了左上角形成的正方形下方的最长’1’序列的长度，同理$b_{i,j-1}$就表示了左上角形成的正方形右方的最长’1’序列的长度。在思路一中的算法，我们每次都是重复检查同一个位置的数据，导致算法效率降低。容易得出，这种算法的时间效率为$O(n^2)$。

代码：

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