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

class Solution {

public:

    int maximalRectangle(vector<vector<char>>& matrix) {

        int res = ;

        if(matrix.empty())

            return res;

        int n = matrix[].size();

        vector<int> cals(n, );

        for(int i = ; i < matrix.size(); ++i){

            for(int j = ; j < n; ++j){

                cals[j] = matrix[i][j] == '' ?  : cals[j] + ;

            }

            res = max(res, maxRectangleArea(cals));

        }

        return res;

    }

private:

    int maxRectangleArea(vector<int> &nums){

        int n = nums.size();

        int res = , area = ;

        nums.push_back();

        stack<int> s;

        for(int i = ; i <= n;){

            if(s.empty() || nums[s.top()] <= nums[i])

                s.push(i++);

            else {

                int cur = s.top(); s.pop();

                area = nums[cur] * (s.empty() ? i : (i - s.top() - ));

                res = max(res, area);

            }

        }

        return res;

    }

};

class Solution {

public:

    int maximalRectangle(vector<vector<char>>& matrix) {

        int res = ;

        if(matrix.empty())

            return res;

        int n = matrix[].size();

        vector<int> height(n, ), left(n, ), right(n, n);

        for(int i = ; i < matrix.size(); ++i){

            int l = , r = n;

            for(int j = ; j < n; ++j){

                if(matrix[i][j] == ''){

                    ++height[j];

                    left[j] = max(left[j], l);

                } else {

                    l = j + ;

                    height[j] = ;

                    left[j] = ;

                    right[j] = n;

                }

            }

            for(int j = n - ; j >= ; --j){

                if(matrix[i][j] == ''){

                    right[j] = min(right[j], r);

                    res = max(res, height[j] * (right[j] - left[j]));

                } else {

                    r = j;

                }

            }

        }

        return res;

    }

};