LeetCode 221. Maximal Square 最大正方形(C++/Java)

题目：

Given a 2D binary matrix filled with 0's and 1's, find the largest square containing only 1's and return its area.

Example:

Input: 

1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 0 0 1 0

Output: 4

分析：

给定一个二维数组，其中的元素是0或者1，求最大的正方形的面积(1的个数)，正方形是指内部全为1的区域。

定义一个新的二维数组dp，dp[i][j]表示以(i, j)元素为右下角的最大正方形的边长。dp[i][j]受到dp[i-1][j]，dp[i][j-1]，dp[i-1][j-1]影响，以下面为例说明。

1 1 1 　　1 1 1　　
1 1 1 　　1 2 2
0 1 1 　　0 1 ？

左侧是所给的二维数组matrix，右侧是我们求得的dp数组，此时我们要求dp[2][2]，也就是以matrix[2][2]为右下角的最大正方形的边长，实际上它收到左方上方和左上方的值影响，因为左侧元素上侧元素和左上侧元素同样分别是以他们各自为右下角元素的最大正方形边长，而如果当前位置的元素为1的话，意味着这个元素可以和那三个元素拼接成更大的正方形，所以在他们中选取最小的值加1，便是dp[2][2]的值，？处应填2，实际上：

if(matrix[i][j] == '1')
    dp[i][j] = Math.min(Math.min(dp[i-1][j], dp[i][j-1]), dp[i-1][j-1]) + 1;  

程序：

C++

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        if(matrix.empty())
            return 0;
        int m = matrix.size();
        int n = matrix[0].size();
        vector<vector<int>> dp(m, vector<int>(n, 0));
        int result = 0;
        for(int i = 0; i < m; ++i){
            for(int j = 0; j < n; ++j){
                if(matrix[i][j] == '0')
                    continue;
                if(i == 0 || j == 0){
                    dp[i][j] = matrix[i][j] - '0';
                }
                else{
                    dp[i][j] = min(min(dp[i-1][j], dp[i][j-1]), dp[i-1][j-1]) + 1;
                }
                result = max(dp[i][j] * dp[i][j], result);
            }
        }
        return result;
    }
};

Java

class Solution {
    public int maximalSquare(char[][] matrix) {
        if(matrix.length == 0 || matrix == null)
            return 0;
        int m = matrix.length;
        int n = matrix[0].length;
        int[][] dp = new int[m][n];
        int result = 0;
        for(int i = 0; i < m; ++i){
            for(int j = 0; j < n; ++j){
                if(matrix[i][j] == '0')
                    continue;
                if(i == 0 || j == 0){
                    dp[i][j] = matrix[i][j] - '0';
                }
                else{
                    dp[i][j] = Math.min(Math.min(dp[i-1][j], dp[i][j-1]), dp[i-1][j-1]) + 1;
                }
                result = Math.max(dp[i][j] * dp[i][j], result);
            }
        }
        return result;
    }
}