436. Maximal Square

436. Maximal Square

Tag:

Dynamic Problem.

Main Idea:

2D Matrix Rolling Array Problem. Let $\ dp[i][j]$ means the maximum square edge. The first thing to do is initialization, for all $\ dp[0][j] = matrix[0][j]$, and $\ dp[i][0] = matrix[i][0]$. The update equation is IF $\ matrix[i][j]$ is true, then $\ dp[i][j] = 1 + min(dp[i-1][j-1], dp[i][j-1], dp[i-1][j])$.

For optimization, we can reserve only two row for lookup, which would be row[i] and row[i-1].

Tips/Notes:

1. In c++, min/max function can only compare two elements.
2. $\ matrix[i][j]$ and $\ dp[i][j]$ can be confusing sometimes. Note that the update equation uses $\ matrix[i][j]$ as condition, but update $\ dp[i][j]$.
3. Finally, iterate the matrix, find the maximum $\ dp[i][j]$ and return the square of it.

Time/Space Cost:

Time Cost: $\ O(nm)$
Space Cost: $\ O(nm)$, $\ O(2n)$ for optimization.

Code:

class Solution {
public:
    /**
     * @param matrix: a matrix of 0 and 1
     * @return: an integer
     */
    int maxSquare(vector<vector<int>> &matrix) {
        // write your code here]
        int row = matrix.size();
        int col = (row == 0)? 0 : matrix[0].size();
        
        vector<vector<int>> dp(row, vector<int>(col,0) );
        
        // initialization
        for(int i = 0; i < row; i++){
            dp[i][0] = matrix[i][0];
        }
        
        for(int j = 0; j < col; j++){
            dp[0][j] = matrix[0][j];
        }
        
        // update dp[i][j]
        for(int i = 1; i < row; i++){
            for(int j = 1; j < col; j++){
                if(matrix[i][j])
                	// note1 mentioned above
                    dp[i][j] = 1 + min(min(dp[i-1][j-1], dp[i-1][j]), dp[i][j-1]);
                
            }
        }
        
        int ans = 0;
        for(int i = 0; i < row; i++){
            for(int j = 0; j < col; j++){
                ans = max(ans, dp[i][j]);
            }
        }
        
        return ans * ans;
    }
};

Followup Problem:

1. what if we want to get the maximum diagonal matrix, which the numbers on the diagonal are 1 only.

Main Idea:

Based on the original problem, the update equation would be: $\ dp[i][j] = 1 + min(dp[i-1][j-1], Left[i][j-1], Up[i-1][j])$. Apparently, we need to maintain three matrix $\ dp[i][j], Left[i][j], Up[i][j]$.

Time/Space Cost:

Time Cost: $\ O(nm)$
Space Cost: $\ O(3nm)$, $\ O(2n * 3)$ for optimization.