0x01題目

85. Maximal Rectangle

Given a 2D binary matrix filled with 0's and 1's,  find the largest rectangle 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 6.

0x02解析

使用動態規劃的思想去解決這個問題，自己總結的動態規劃三要素：定義概念、邊界初始化、一般情況遞推，兩個難點是：角標索引問題

、遞推情況剖析。
cur_left定義為在一個字元陣列中，當前元素可以延伸到最左邊元素的下標（當前元素為0，則這個值為0）。如在字元陣列"0111001110"，對第三個1，其cur_left=1，對最後一個0，其cur_left=0。其示意圖如下圖所示

cur_right定義為在一個字元陣列中，當前元素可以延伸到最右邊元素的下標+1（當前元素為0，則這個值為字元陣列的長度）。如在字元陣列"0111001110"，對第四個1，其cur_right=8+1，對第一個0，其cur_right=10，其示意圖如下圖所示

總結：cur_left和cur_right均由當前行的值來確定。如果當前值為'1'，則cur_left和cur_right均不變；如果當前值為'0'，則cur_left值為當前元素右側，cur_right值為當前元素位置。（左閉右開）
left[i][j]定義為在第i行第j列處，可以延伸到最左邊元素的下標。
right[i][j]定義為在第i行第j列處，可以延伸到最右邊元素的下標+1。
核心思路是從第一行開始一行一行地處理，使[i, j]處最大子矩陣的面積是(right(i, j)-left(i, j))*height(i, j)。其中height統計當前位置及往上'1'的數量；left和right是高度是當前點的height值的左右邊界，即是以當前點為中心，以height為高度向兩邊擴散的左右邊界。

left(i,j) = max(left(i-1,j), cur_left)

right(i,j) = min(right(i-1,j), cur_right)

if matrix[i][j]=='1', height(i,j) = height(i-1,j) + 1;
if matrix[i][j]=='0', height(i,j) = 0;

left、right和height的值均可以通過前一行和當前行的值來確定，因此，逐行遍歷即可。

舉例說明。字元長方形如下：

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

則left（l）、right（r）和height（h）的值如下所示

row 0:
    l: 0 0 0 3 0 0 0
    r: 7 7 7 4 7 7 7
    h: 0 0 0 1 0 0 0
row 1:
    l: 0 0 2 3 2 0 0
    r: 7 7 5 4 5 7 7 
    h: 0 0 1 2 1 0 0 
row 2:
    l: 0 1 2 3 2 1 0
    r: 7 6 5 4 5 6 7
    h: 0 1 2 3 2 1 0

0x03程式碼

public class Solution {
    public int maximalRectangle(char[][] matrix) {
        if(matrix == null || matrix.length == 0 || matrix[0] == null) return 0;

        int m = matrix.length, n = matrix[0].length;
        int[] l = new int[n];
        int[] r = new int[n];
        int[] h = new int[n];
        int result = 0;

        for(int i = 0; i < n; i++){
            l[i] = 0;
            r[i] = n;
            h[i] = 0;
        }
        for(int i = 0; i < m; i++){
            int cur_left = 0, cur_right = n;
            for(int j = 0; j < n; j++){
                if(matrix[i][j] == '1') h[j] += 1;
                else                    h[j] = 0;
//              System.out.print(h[j]);
//              System.out.print(" ");
            }
            for(int j = 0; j < n; j++){
                if(matrix[i][j] == '1'){
                    l[j] = Math.max(l[j], cur_left);
                }
                else{
                    l[j] = 0;
                    cur_left = j + 1;
                }
//              System.out.print(l[j]);
//              System.out.print(" ");
            }
            for(int j = n-1; j >= 0; j--){
                if(matrix[i][j] == '1'){
                    r[j] = Math.min(r[j], cur_right);
                }
                else{
                    r[j] = n;
                    cur_right = j;
                }
//              System.out.print(r[j]);
//              System.out.print(" ");
            }
            for(int j = 0; j < n; j++){
                result = Math.max(result, (r[j] - l[j]) * h[j]);
            }
            System.out.println();
        }

        return result;
    }
}

參考 https://discuss.leetcode.com/topic/6650/share-my-dp-solution
參考 http://blog.csdn.net/makuiyu/article/details/44857479