LintCode 631: Maximal Square II (DP经典题)

631. Maximal Square II

Given a 2D binary matrix filled with 0’s and 1’s, find the largest square which diagonal is all 1 and others is 0.

Example
Example 1:

Input:
[[1,0,1,0,0],[1,0,0,1,0],[1,1,0,0,1],[1,0,0,1,0]]
Output:
9
Explanation:
[0,2]->[2,4]
Example 2:

Input:
[[1,0,1,0,1],[1,0,0,1,1],[1,1,1,1,1],[1,0,0,1,0]]
Output:
4
Explanation:
[0,2]->[1,3]
Notice
Only consider the main diagonal situation.

解法1：DP。时间复杂度O(n^3)。
dp[i][j]表示以matrix[i][j]为右下角的只有主对角线全为1的最大正方形边长。
所以dp[i + 1][j + 1] = dp[i][j] + 1只有当最下面一行和最右边一列全为0才成立。
未优化版本代码如下:

class Solution {
public:
    /**
     * @param matrix: a matrix of 0 an 1
     * @return: an integer
     */
    int maxSquare2(vector<vector<int>> &matrix) {
        int m = matrix.size();
        if (m == 0) return 0;
        int n = matrix[0].size();
        vector<vector<int>> dp(m, vector<int>(n));
        int gMax = 0;
        
        for (int i = 0; i < m; ++i) {
            if (matrix[i][0] == 1) {
                dp[i][0] = 1;
                gMax = 1;
            }
        }
        
        for (int i = 0; i < n; ++i) {
            if (matrix[0][i] == 1) {
                dp[0][i] = 1;
                gMax = 1;
            }
        }
        
        for (int i = 1; i < m; ++i) {
            for (int j = 1; j < n; ++j) {
    
                if (matrix[i][j] == 0) {
                    dp[i][j] = 0;
                } else {
                    int prevSize = dp[i - 1][j - 1];
                    bool twoBorderZero = true;
                    for (int k = 1; k <= prevSize; ++k) {
                        if (matrix[i - k][j] == 1 || matrix[i][j - k] == 1) {
                            dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                            twoBorderZero = false;
                            break;
                        }
                    }
                    
                    if (twoBorderZero && matrix[i][j] == 1) {
                        dp[i][j] = dp[i - 1][j - 1] + 1;
                        gMax = max(gMax, dp[i][j]);               
                    }
                }
         
            }
        }
        
        return gMax * gMax;
    }
};

解法2：
可在解法1的基础上优化。即最下面一行和最右边一列可以预处理。这样时间复杂度就是O(n^2)了。
TBD。