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.

For example,
Given heights = [2,1,5,6,2,3],
return 10.

分析：

最大矩形的高度必然和某一个立柱的高度相等，也就是说，最大矩形必然包含了某一个立柱的全部。
因此，可以遍历所有立柱，对当前立柱 i，以其高度左右扩展，看看以当前立柱 i 的高度最多能包含进
多大的矩形面积。最后选出最大的总面积即可。这种思路的代码如下：
c++代码：

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        if(heights.size()==0) return 0;
        int max=0;
        for(int i=0;i<heights.size();i++)
        {
            int area=0;
            int mid=i;
            for(;mid>=0 && heights[mid]>=heights[i];mid--)
            {
                area+=heights[i];
            }
            for(mid=i+1;mid<heights.size() && heights[mid]>=heights[i];mid++)
            {
                area+=heights[i];
            }
            if(max<area) max=area;
        }
        return max;
    }
};

python代码：

class Solution(object):
    def largestRectangleArea(self, heights):
        """
        :type heights: List[int]
        :rtype: int
        """
        if len(heights)==0: return 0
        maxArea=0
        for i in range(len(heights)):
            area=0
            for mid in range(i,-1,-1):
                if heights[mid]>=heights[i]:
                    area+=heights[i]
                else:
                    break
            for mid in range(i+1,len(heights)):
                if heights[mid]>=heights[i]:
                    area+=heights[i]
                else:
                    break
            if maxArea<area:
                maxArea=area
        return maxArea

上述解法的间复杂度是O(n^2)，过不了大集合测试！

下面我们看一个时间复杂度为O(n)的解法：
首先我们看一下下面的例子：

heights的内容是 [5,6,7,8,3]，特点是除了最后一个，前面全部保持递增，且最后一个立柱的高度
小于前面所有立柱高度。对于这种特点的柱状图，除了最后一个，从第一个到倒数第二个立柱的高度
都在升高，那么如果挨个使用每一个柱的高度作为矩形的高度，那么依次能得到的矩形的宽度就可以
直接算出来：使用5作为高度可以使用前四个立柱组成 4*5的矩形，高度6可以组成3*6的矩形... 
因此只需要遍历一次，选出最大面积即可。
对于这种类型的柱状图，求最大矩形面积的时间复杂度是O(n)！
我们将这种特点的柱状图称为“波峰图”。
下面介绍新的解法的步骤：
(1) 在heights尾部添加一个0，也就是一个高度为0的立柱。作用是在最后也能凑成上面提的那种“波峰图”。
(2) 定义了一个stack，然后遍历heights，如果heights[i] 大于等于stack.top()，进栈。
如果heights[i]小于stack.top()，出栈，直到heights[i] 大于等于stack.top()，然后进栈。
由于出栈的这些元素高度都是递增的，我们可以求出这些立柱中所围成的最大矩形。更妙的是，
由于这些被弹出的立柱处于“波峰”之上(比如弹出i 到 i+k，那么所有这些立柱的高度都
高于 i-1和 i+k+1的高度)，因此，如果我们使用之前所提的“左右延伸找立柱”的思路解，
以这些立柱的高度作为整个矩形的高度时，左右延伸出的矩形所包含的立柱不会超出这段“波峰”，
因为波峰外的立柱高度都比他们低。“波峰图”其实就是求解最大矩形的“孤岛”，它不会干扰到外部。
(3)由于比heights[i]大的元素都出完了，heights[i]又大于等于栈顶元素了，因此再次进栈。如此往复，
直到遍历到最后那个高度为0的柱，触发最后的弹出以及最后一次面积的计算。。。。
(4)返回面积最大值。
另外，需要注意的是：栈中存的不是高度，而是heights的索引，这样做的好处是:
不会影响宽度的计算，索引值相减 = 宽度。
c++代码：

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        if(heights.size()==0) return 0;
        stack<int> st;
        int max=0;
        heights.push_back(0);
        int leftarea=0,rightarea=0;
        for(int i=0;i<heights.size();i++)
        {
            while(!st.empty() && heights[st.top()]>heights[i])
            {
                int tmp=st.top();
                st.pop();
                //以tmp为高度，tmp所在柱以及向左延伸出来的矩形面积
                leftarea=(st.empty()? tmp+1 : tmp-st.top())*heights[tmp];
                //以tmp为高度，向右边延伸出来的矩形面积
                rightarea=(i-tmp-1)*heights[tmp];
                if( (leftarea+rightarea)>max ) max=leftarea+rightarea;
            }
            st.push(i);
        }
        return max;
    }
};

python代码：

class Solution(object):
    def largestRectangleArea(self, heights):
        """
        :type heights: List[int]
        :rtype: int
        """
        if len(heights)==0: return 0
        l=[] #用列表来模拟一个栈
        maxArea=0;
        heights.append(0)
        leftArea,rightArea=0,0
        for i in range(0,len(heights)):
            while len(l)!=0 and heights[l[len(l)-1]]>heights[i]:
                tmp=l[len(l)-1]
                l.pop()
                #以tmp为高度，tmp所在柱以及向左延伸出来的矩形面积
                leftArea=(tmp+1 if len(l)==0 else tmp-l[len(l)-1])*heights[tmp]
                #以tmp为高度，向右边延伸出来的矩形面积
                rightArea=(i-tmp-1)*heights[tmp]
                if (leftArea+rightArea)>maxArea:
                    maxArea=leftArea+rightArea
            l.append(i)
        return maxArea

参考资料： 点击打开链接