[LeetCode 84, 85]Largest Rectangle in Histogram / Maximal Rectangle

LeetCode 84. Largest Rectangle in Histogram

Given n non-negative integers representing the histogram’s bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.

Above is a histogram where width of each bar is 1, given height = [2,1,5,6,2,3].

The largest rectangle is shown in the shaded area, which has area = 10 unit.

---

很自然的可以想到一个朴素的算法。显然，最大矩形的高，必然为某个元素的高度。因此，枚举每个元素，向两边尽可能的扩展，找到以这个元素作为高度的最大矩形，最终得到总体的最大矩形。向两侧扩展的复杂度为O(n)，一共要进行n次，总复杂度为O(n^2)。（这个算法不足以AC）

如果要找出最冗余的地方，首先就是“向两侧扩展”这个操作花费了太多的时间。我们稍加观察就会觉得，一格一格的扩展效率太低，而且没有用到上一次枚举的信息。因此，改进算法的思路应该在于维护某些信息，以便于快速确定边界。

经过题目的Tag的提示，会想到使用栈，在遍历元素的时候做入栈出栈的操作。进而可得到这样一个算法。

遍历所有元素，当遍历到一个元素i时，看看加入元素i后，栈的元素是不是仍保持升序，如果不是，不断的出栈直到可以保持升序。当元素j出栈时，新的栈顶元素就是以元素j为高度的矩形的左边界，而元素i是右边界。以此可以O(1)计算矩形面积。

也就是说在元素j出栈的时，始终有

heights[j] <= heights[stack.top()+1]
heights[j] <= heights[i-1]

此算法的复杂度为O(n)，以下是代码

int largestRectangleArea(vector<int>& heights) {
    //数组末尾补充一个哨兵，以方便算法终结
    heights.push_back(0);
    int n = heights.size();
    int max_s = 0;

    stack<int> stk;
    stk.push(0);
    for (int i = 1; i < n; ++i) {
        int cur_s;
        //不断出栈，直到使得新元素入栈后仍保持升序
        //元素出栈时，计算以该元素为高度的矩形的面积
        for (int idx = stk.top(); heights[i] < heights[idx]; idx = stk.top()) {
            stk.pop();

            //若栈空，则矩形左侧可延伸到左界，右侧延伸到i处
            if (stk.empty()) cur_s = i * heights[idx];
            //若不空，则矩形左侧可延伸到栈顶元素，右侧可延伸到i处
            else cur_s = (i - stk.top() - 1) * heights[idx];

            if (max_s < cur_s) max_s = cur_s;
            if (stk.empty()) break;
        }
        stk.push(i);
    }

    return max_s;
}

---

LeetCode 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.

========

第85题可以用第84题的算法做，对于每一行，取此行上面的连续的1作为上题中的柱体，用O(n)求出最大矩形。总复杂度O(mn)

int maximalRectangle(vector<vector<char> >& matrix) {
    //得到矩阵尺寸
    int m = matrix.size();
    if (m == 0) return 0;
    int n = matrix[0].size();
    if (n == 0) return 0;
    //建立heights表
    vector<int> heights(n+1, 0);
    int max_s = 0;

    //对于每行，进行一次求最大矩形的操作，一共m次
    for (int k = 0; k < m; ++k) {
        //对于每一行，先求出新的heights表
        for (int i = 0; i < n; ++i) {
            if (matrix[k][i] == '1')
                heights[i]++;
            else
                heights[i] = 0;
        }
        stack<int> stk;
        stk.push(0);
        //每一行求最大矩形的时间为O(n)
        for (int i = 1; i <= n; ++i) {
            int cur_s;

            for (int idx = stk.top(); heights[i] < heights[idx]; idx = stk.top()) {
                stk.pop();
                if (stk.empty()) cur_s = i * heights[idx];
                else cur_s = (i - stk.top() - 1) * heights[idx];
                if (max_s < cur_s) max_s = cur_s;
                if (stk.empty()) break;
            }
            stk.push(i);
        }
    }

    //总体复杂度为O(mn)
    return max_s;
}