[LeetCode] Maximal Square(！！！！DP优化）

定义一个D[i][j] 表示的是以i,j为右下角的最大子正方形的边长。这个边长是受限于D[i-1][j]，D[i][j-1] ，D[i-1][j-1]中最小的那个的。

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

    }
};

12ms AC

这里的方法需要两次初始化，代码可以被进一步优化。因为每次D[i][j]的求解 只依赖于D[i-1][j]，D[i][j-1] ，D[i-1][j-1]，所以实际上可以只维护两个行向量或列向量，这样空间复杂度变成了O(2m)或O(2n)

class Solution {
public:
    int maximalSquare(vector<vector<char>>& A) {
        int m = A.size();   if(m==0)    return 0;
        int n = A[0].size();    if(n==0)    return 0;
        vector<int> pre(n,0);
        vector<int> curr(n,0);
        int max_area=0;
        for(int i=0; i<n; ++i){
            pre[i]=A[0][i]-'0';
            if(A[0][i]=='1')
                max_area = 1;
        }
        for(int i =1; i<m; ++i){
            curr[0]=A[i][0]-'0';
            for(int j = 1; j<n; ++j)
                    if(A[i][j]=='1'){
                        curr[j]= min(min(pre[j-1],pre[j]),curr[j-1])+1;
                        max_area = max(max_area, curr[j]);
                    }
            //swap(pre,curr);
            //curr=vector<int>(n,0);
            pre.swap(curr);
            fill(curr.begin(),curr.end(),0);

        }
        return max_area*max_area;

    }
};

上面的swap(两种swap都是可以的）操作查了下是常数级的时间复杂度，它不涉及到元素的复制、移动、交换操作。这样的方式和使用指针的效果是相同的。

其实进一步优化可以将空间复杂度降低到O(m)

int maximalSquare(vector<vector<char>>& matrix) {
    if (matrix.empty()) return 0;
    int m = matrix.size(), n = matrix[0].size();
    vector<int> dp(m + 1, 0);
    int maxsize = 0, pre = 0;
    for (int j = 0; j < n; j++) {
        for (int i = 1; i <= m; i++) {
            int temp = dp[i];
            if (matrix[i - 1][j] == '1') {
                dp[i] = min(dp[i], min(dp[i - 1], pre)) + 1;
                maxsize = max(maxsize, dp[i]);
            }
            else dp[i] = 0; 
            pre = temp;
        }
    }
    return maxsize * maxsize;
}