221. 最大正方形

题目

动态规划

假设每一个元素为最大正方形的右下角点，那么可以对每个元素维护其对应最大正方形的边长 dp[i][j] ，首先考虑第一行或第一列的元素，发现边长只能为 0 或 1 ，再来考虑其他元素，可以发现边长只与左边元素、上边元素、左上方元素的边长有关，时间复杂度为 $O(mn)$ ，空间复杂度为 $O(mn)$ ：

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

由于每个元素只用到上一行的 dp 值以及前一个元素的 dp 值，因此可以用一维数组和一个变量来记录 dp 表，从而使得空间复杂度降为 $O(n)$ ：

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        int m = matrix.size(), n = matrix[0].size();
        vector<int> dp(n, 0);
        int ans = 0, pre;
        for(int i=0; i<n; ++i) {
            matrix[0][i] == '1' ? dp[i] = 1 : dp[i] = 0;
            ans = max(ans, dp[i]);
        }
        for(int i=1; i<m; ++i) {
            matrix[i][0] == '1' ? pre = 1 : pre = 0;
            ans = max(ans, pre);
            for(int j=1; j<n; ++j) {
                if(matrix[i][j]=='1') {
                    int tmp = min(pre, min(dp[j], dp[j-1])) + 1;
                    dp[j-1] = pre;
                    pre = tmp;
                }
                else {
                    dp[j-1] = pre;
                    pre = 0;
                }
                ans = max(ans, pre);
            }
            dp[n-1] = pre; // 别忘记修改最后一个元素的dp值
        }
        return ans * ans;
    }
};