leetcode: Maximal Rectangle

Largest Rectangle in Histogram Apr 23 '12 1499 / 4823

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 height = [2,1,5,6,2,3],
return 10.

下面的方法尽管能通过small judge, 但是对于large judge却编译不过，关键是时间复杂度为O(n*n)

class Solution {
public:
    int largestRectangleArea(vector<int> &height) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        
        int maxVal = 0;
        int vectorSize = height.size();
        for (int idx=0; idx<vectorSize; idx++)
        {
            
            int curVal   = 0;
            int leftIdx  = idx-1;
            int rightIdx = idx+1;
            
            for (; leftIdx>=0; leftIdx--)
            {
                if (height[leftIdx] < height[idx])
                {
                    break;
                }
            }
            leftIdx++;
            
            for (; rightIdx<vectorSize; rightIdx++)
            {
                if (height[rightIdx] < height[idx])
                {
                    break;
                }
            }
            rightIdx--;
            
            curVal = (rightIdx-leftIdx+1) * height[idx];
            
            if (curVal > maxVal)
                maxVal = curVal;
                
        }
        
        return maxVal;
    }
};

网上看到另外一种做法，借助stack来完成，算法很神奇 class Solution {

class Solution {
public:
    int largestRectangleArea(vector<int> &height) {
        
        if (height.size() == 0)
            return 0;
    
        int maxArea = 0;
        stack<int> stackHeight;
        stack<int> stackIndex;
    
        for (int i = 0; i < height.size(); i++) 
        {
            //case 1
            if (stackHeight.empty() || height[i] > stackHeight.top()) 
            {
                stackHeight.push(height[i]);
                stackIndex.push(i);
            } 
            else if (height[i] < stackHeight.top()) 
            {
	            // case 3
	            int lastIndex = 0;
	            while (stackHeight.empty() == false && height[i] < stackHeight.top()) 
                {
	        	    lastIndex = stackIndex.top();
                    stackIndex.pop();
                
                
	                int tempArea = stackHeight.top() * (i - lastIndex);
                    stackHeight.pop();
	                if (maxArea < tempArea) 
                    {
	                    maxArea = tempArea;
	                }
	            }
                stackHeight.push(height[i]);
                stackIndex.push(lastIndex);
            }
        }
    
        while(stackHeight.empty() == false) 
        {
            int tempArea = stackHeight.top() * (height.size() - stackIndex.top());
            stackHeight.pop();
            stackIndex.pop();
        
            if (tempArea > maxArea) 
            {
                maxArea = tempArea;
            }
        }
        return maxArea;
    }
        
};