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.

摘自：http://www.cnblogs.com/felixfang/p/3676193.html

http://www.cnblogs.com/avril/archive/2013/08/24/3278873.html

https://discuss.leetcode.com/topic/7599/o-n-stack-based-java-solution

-----------------------------------------------------------------------------------------------------------------------------------------

首先我们看一下下面的例子：

 

height的内容是 [5,6,7,8,3]，特点是除了最后一个，前面全部保持递增，且最后一个立柱的高度小于前面所有立柱高度。

对于这种特点的柱状图，如果使用上面所说的“挨个使用每一个柱状图的高度作为矩形的高度，求面积”的方法，还需要用嵌套循环吗？

我们知道除了最后一个，从第一个到倒数第二个立柱的高度都在升高，那么如果挨个使用每一个柱的高度作为矩形的高度，那么依次能得到的矩形的宽度就可以直接算出来：使用5作为高度可以使用前四个立柱组成 4*5的矩形，高度6可以组成3*6的矩形... 因此只需要遍历一次，选出最大面积即可。

对于这种类型的柱状图，最大矩形面积的时间复杂度是O(n)。

我们将这种特点的柱状图称为“波峰图”。

 

下面介绍新的解法的步骤：

(1) 在height尾部添加一个0，也就是一个高度为0的立柱。作用是在最后也能凑成上面提的那种“波峰图”。

(2) 定义了一个stack，然后遍历时如果height[i] 大于stack.top()，进栈。反之，出栈直到栈顶元素小于height[i]。

由于出栈的这些元素高度都是递增的，我们可以求出这些立柱中所围成的最大矩形。更妙的是，由于这些被弹出的立柱处于“波峰”之上(比如弹出i 到 i+k，那么所有这些立柱的高度都高于 i-1和 i+k+1的高度)，因此，如果我们使用之前所提的“左右延伸找立柱”的思路解，以这些立柱的高度作为整个矩形的高度时，左右延伸出的矩形所包含的立柱不会超出这段“波峰”，因为波峰外的立柱高度都比他们低。“波峰图”其实就是求解最大矩形的“孤岛”，它不会干扰到外部。

(3) 由于比height[i]大的元素都出完了，height[i]又比栈顶元素大了，因此再次进栈。如此往复，直到遍历到最后那个高度为0的柱，触发最后的弹出以及最后一次面积的计算，此后stack为空。

(4) 返回面积最大值。

栈中存的不是高度，而是height的索引，这样做的好处是不会影响宽度的计算，索引值相减 = 宽度。

代码如下，虽然是二重循环，但时间复杂度实际  2N，故为O(N)

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

------------------------------------------------------------------------------------------------------------------------------------------

在高度数组的最后一个位置当做补了一个0，维护一个栈，栈里保存的内容是index，每次遇到比栈顶大的高度就入栈，否则出栈计算当前高度围成的面积。

public static int largestRectangleArea(int[] height)
	{
		int area = 0;
		int len=height.length;
		Stack<Integer> stack = new Stack<Integer>();
		int i=0;
		
		while(i <= len)
		{
			int h = (i == len ? 0 : height[i]);
			if (stack.empty() || height[stack.peek()] < h)
			{
				stack.push(i);
				i++;
			}
			else
			{
				int start = stack.pop();
				int width = stack.empty() ? i : i - stack.peek() - 1;
				area = Math.max(area, height[start] * width);
			}
		}
		return area;
	}

-----------------------------------------------------------------------------------------------------------

O(N^2)的：对每一个矩形柱，从中心开始 “尽可能地”  往左边和右边扩展使面积最大，先扩展左端，再扩展右端，遇到扩展以后面积小于以当前为中心点已经找到的最大面积的情况回退。

public static int largestRectangleArea(int[] heights)
	{
		int len = heights.length;
		int max = 0;
		for (int i = 0; i < len; i++)
		{
			int start = i;
			int end = i;
			int currentmax = heights[i];
			int shortest = heights[i];
			while (start > 0)
			{
				start--;
				int shortestcpy = shortest;
				if (heights[start] < shortest)
					shortest = heights[start];
				int sum = (end - start + 1) * shortest;
				if (sum >= currentmax)
					currentmax = sum;
				else
				{
					start++;
					shortest = shortestcpy;
					break;
				}
			}
			while (end < len - 1)
			{
				end++;
				int shortesecpy = shortest;
				if (heights[end] < shortest)
					shortest = heights[end];
				int sum = (end - start + 1) * shortest;
				if (sum >= currentmax)
					currentmax = sum;
				else
				{
					end--;
					shortest = shortesecpy;
					break;
				}
			}
			if (currentmax > max)
				max = currentmax;
		}

		return max;
	}