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

For example, given the following matrix:

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

Return 4.
找到最大的全是1的方块。
我最开始的想法比较笨。。。
先走一遍矩阵，把是1的都记录下来，那么边长为2的方块只可能以这些点为起点。
遍历先前的记录，找到真的有边长为2的方块的起点，更新记录，再去找3的。

var maximalSquare = function(matrix) {
    var row = matrix.length;
    if (row===0)
        return 0;
    var col = matrix[0].length;
    var count = 0;
    var rec = [];
    var newRec = [];
    for (let i = 0;i < row;i++) {
        for (let j = 0;j < col;j++) {
            if (matrix[i][j]==='1') 
                rec.push([i,j]);
        }
    }
    while (rec.length!==0) {
        count++;
        check:while (rec.length!==0) {
            let nowCheck = rec.pop();
            let a = nowCheck[0];
            let b = nowCheck[1];
            let c = nowCheck[0] + count;
            let d = nowCheck[1] + count;
            if (c >= row||d >= col)
                continue;
            for(let i = a;i <= c;i++) {
                for (let j = b;j <= d;j++) {
                    if (matrix[i][j]==='0')
                        continue check;
                }
            }
            newRec.push([a,b]);
        }
        rec = newRec;
        newRec = [];
    }
    return count*count;
};

嗯，这个方法的运行时间成功的击败了4%的人。。。。。。。。。。
看了人家的方法。。。。。
利用这个矩阵边遍历边记录以这个点做右下角能达到的最大的方块的边长，有以下2种情况：
matrix[0][j]和matrix[i][0]，第一行和第一列，如果是‘1’，那就意味着这个点的记录就是1，因为已经在边上了，以它为右下角并不能组成更大的正方形，如果是‘0’那自然就是0了。
对于其他的点，如果是0，当然只可能是0了，是1的话就取：

min(matrix[i - 1][j - 1], matrix[i - 1][j], matrix[i][j - 1]) + 1

var maximalSquare = function(matrix) {
    let m = matrix.length;
    if (m === 0) return 0;
    var n = matrix[0].length;
    var maxsize = 0;
    //利用原来的数组，
    for (let j = 0; j < n; j++) {
        matrix[0][j] = matrix[0][j] - '0';
        maxsize = Math.max(maxsize, matrix[0][j]);
    }
    for (let i = 1; i < m; i++) {
        matrix[i][0] = matrix[i][0] - '0';
        maxsize = Math.max(maxsize, matrix[i][0]);
    }
    for (let i = 1; i < m; i++) {
        for (let j = 1; j < n; j++) {
            if (matrix[i][j] == '1') {
                matrix[i][j] = Math.min(matrix[i - 1][j - 1], matrix[i - 1][j], matrix[i][j - 1]) + 1;
                maxsize = Math.max(maxsize, matrix[i][j]);
            }
        }
    }
    return maxsize * maxsize;
};