Maximal Rectangle

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

看到2D，首先想到的就是那个二维矩阵中找最大子矩阵。同样也是可以降级到一维：

给一个array，里面有1 和 0， 找联续1的最大长度。

这个问题很好解决，即function findMax。然后再递归到二维即可。

方法是先把bot定为最底层，然后把top从bot往上移，如果竖向看全1，则将抽象这个矩形的数组本位设为1，否则为0。然后找最大长度，乘上其放大倍数，级top - bot + 1，即为这一层的max。

然后慢慢往上移bot，知道到最高层，找出这些局部max中最大的那个，即为全局max，返回。

public class Solution {
    public int maximalRectangle(char[][] matrix) {
        // Start typing your Java solution below
        // DO NOT write main() function
        if(matrix == null || matrix.length == 0) return 0;
        int n = matrix.length;
        int m = matrix[0].length;
        int[] cur = new int[m];
        int max = 0;
        for(int i = 0; i < n; i ++){
            for(int j = i; j < n; j ++){
                for(int l = 0; l < m; l ++){
                    boolean sig = true;
                    for(int g = i; g < j + 1; g ++){
                        if(matrix[g][l] == '0'){
                            sig = false;
                            break;
                        }
                    }
                    cur[l] = ((sig == true) ? 1 : 0);
                }
                int curmax = findMax(cur) * (j - i + 1);
                if(curmax > max) max = curmax;
            }
        }
        return max;
    }
    public int findMax(int[] vet){
        int cur = 0;
        int max = 0;
        for(int i = 0; i < vet.length; i ++){
            if(vet[i] == 1) cur ++;
            else{
                if(cur > max) max = cur;
                cur = 0;
            }
        }
        if(cur > max) max = cur;
        return max;
    }
}

这个可以过小测试，大测试超时。 所以引入一个space来存中间结果。这个中间空间即sp。

注意到，当bot不变的时候，每当top往上移的时候，其实不用全部重新算，而是只用拿当前的top层和原来算出来的结果比较即可：

top   原来  ==》 result

1       1                 1

1       0                 0

0       1                 0

0       0                 0

只有一个会改变原来的结果。然后就可以用这个结果去计算了。 所以顺便把findMax也修改了一下。

public class Solution {
    public int maximalRectangle(char[][] matrix) {
        // Start typing your Java solution below
        // DO NOT write main() function
        if(matrix == null || matrix.length == 0) return 0;
        int n = matrix.length;
        int m = matrix[0].length;
        int[] cur = new int[m];
        int max = 0;
        char[][] sp = matrix;
        for(int i = 0; i < n; i ++){
            for(int j = i; j < n; j ++){
                for(int l = 0; l < m; l ++){
                    if(sp[i][l] == '1' && matrix[j][l] == '0'){
                        sp[i][l] = '0';
                    }
                }
                int curmax = findMax(sp[i]) * (j - i + 1);
                if(curmax > max) max = curmax;
            }
        }
        return max;
    }
    public int findMax(char[] vet){
        int cur = 0;
        int max = 0;
        for(int i = 0; i < vet.length; i ++){
            if(vet[i] == '1') cur ++;
            else{
                if(cur > max) max = cur;
                cur = 0;
            }
        }
        if(cur > max) max = cur;
        return max;
    }
}

 在做到这里之后，发现还可以优化，可以将findMax这层循环与原函数的循环合并。

public class Solution {
    public int maximalRectangle(char[][] matrix) {
        // Start typing your Java solution below
        // DO NOT write main() function
        if(matrix == null || matrix.length == 0) return 0;
        int n = matrix.length;
        int m = matrix[0].length;
        int[] cur = new int[m];
        int max = 0;
        char[][] sp = matrix;
        for(int i = 0; i < n; i ++){
            for(int j = i; j < n; j ++){
                int lcur = 0;
                int lmax = 0;
                for(int l = 0; l < m; l ++){
                    if(sp[i][l] == '1' && matrix[j][l] == '0'){
                        sp[i][l] = '0';
                    }
                    if(sp[i][l] == '1') lcur ++;
                    else{
                        if(lcur > lmax) lmax = lcur;
                        lcur = 0;
                    }
                }
                if(lcur > lmax) lmax = lcur;
                int curmax = lmax * (j - i + 1);
                if(curmax > max) max = curmax;
            }
        }
        return max;
    }
}

最终，时间复杂度是O（n2m）。 在最开始的时候我们可以人为的选择小的length 作为n，这样可以进一步降低时间复杂度。

public class Solution {
    public int maximalRectangle(char[][] matrix) {
        if(matrix == null || matrix.length == 0 || matrix[0].length == 0) return 0;
        int len = matrix[0].length;
        int max = Integer.MIN_VALUE;
        for(int base = 0; base < matrix.length; base ++){
            char[] row = matrix[base];
            for(int i = base; i < matrix.length; i ++){
                for(int j = 0; j < len; j ++){
                    if(row[j] == '1') row[j] = matrix[i][j];
                }
                int cur = 0;
                for(int j = 0; j < len; j ++){
                    cur = row[j] == '1' ? cur + 1 : 0;
                    max = Math.max(max, cur * (i - base + 1));
                }
            }
        }
        return max;
    }
}