LeetCode:221. Maximal Square

有一些需要我注意的点以及空间的优化方法。
1.常规dp

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        if (matrix.empty() || matrix[0].empty())
            return 0;
        int rows = matrix.size();
        int cols = matrix[0].size();
        vector<vector<int>> dp(rows, vector<int>(cols, 0));
        int sz = 0;
        for (int i = 0; i < rows; ++i)
            for (int j = 0; j < cols; ++j) {
                if (i == 0 || j == 0 || matrix[i][j] == '0')
                    dp[i][j] = matrix[i][j] - '0';
                else 
                    dp[i][j] = min(dp[i-1][j-1], min(dp[i-1][j], dp[i][j-1])) + 1;
                sz = max(sz, dp[i][j]);
            }
        return sz * sz;
    }
};
//首先，dp[i][j] = min(dp[i-1][j-1], min(dp[i-1][j], dp[i][j-1])) + 1 ，不是很能够理解这样为什么是对的，但是这样确实简单得多，记着吧
//然后，记得这里对边界的处理方法，就可以不用多写几个循环了

dp[i][j] = min(dp[i-1][j-1], min(dp[i-1][j], dp[i][j-1])) + 1这一点确实不是很能够理解。但是这也是做后面方法的基石。

2.两行空间
因为每次计算只涉及到当前以及上一行，所以保持两行就可以了。

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

另外，注意这里的 cur.swap(pre);记得看过一个tip，能用类型自带的swap的话就用自带的，少用通用的swap，因为那会引起复制。

3.一行空间

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        if (matrix.empty() || matrix[0].empty())
            return 0;
        int rows = matrix.size();
        int cols = matrix[0].size();
        int sz = 0;
        vector<int> cur(cols, 0);
        int pre = 0;
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                int temp = cur[j];
                if (i == 0 || j == 0 || matrix[i][j] == '0')
                    cur[j] = matrix[i][j] - '0';
                else 
                    cur[j] = min(pre, min(cur[j], cur[j-1])) + 1;//这里的pre相当于左上角的值，cur[j]相当于上方的值，cur[j-1]就是左边的值
                pre = temp;
                sz = max(sz, cur[j]);
            }
        }
        return sz * sz;
    }
};

给我的感觉就是如果都是这种按照规矩，从左到右的迭代的话，应该都可以变成这种很省空间的做法。