最大面积问题 LargestReactangle

             描述：在下列非负数组中找出最大面积             

Heigh=[0,2,1,3,4,3,2,0]
若干非负数组组成面积不同的矩形，求上述图片中的最大面积。在图中画出了下标[3-5]高度为3，面积为9的矩形和下标为[1-6]，高度为1面积为6的矩形。

思路：暴力遍历
1：从下标i开始，对于每一个高度Heigh[i]=h,向左遍历，如果j<0或Heigh[j]< Heigh[i]，此时H_left=j,即为左边界；
2：向右遍历，若j>length(Heigh)或Heigh[j] < Heigh[i]，此时H_right=j,即右边界；
3：计算以当前Heigh[i]为高，（H_right-H_left-1）为宽的面积并更新最大面积；
4：判断:若i> length(Heigh),则中断循环，否则继续从1开始，i=i+1.
伪代码如下：

MAX_size(Heigh)
{
    H_left=0;
    H_rught=0;
    Max_s=0;
    s_cur=0;
    len=length(Heigh);
    for(i=0;i<len,i++)
    {
        H=Heigh(i);
        for(j=i-1;j>=0;j--)
        {
            if(Heigh(j)<Heigh(i))
            {
                H_left=j;
                break;
            }
        }
        for(j=i+1;j<len;j++)
        {
            if(Heigh(j)<Heigh(i))
            {
                H_right=j;
                break;
            }
        }
        W=H_right-H_left-1;
        s_cur=H*W;
        Max_s=max(Max_s,s_cur)
    }
}

该算法的时间复杂度为O(N^2).
考虑能否在O(N)内完成。
我们找出上图中最大面积并总结规律如下：
1：最大面积中至少包含一个完整的直方；
2：最大面积包含的完整直方对其左右临界的关系：
Heigh(H_left) < Heigh(i);
Heigh(H_right)< Heigh(i).

即如上图所示，最大面积包含了高度为3的直方，其左右临界位置2,6的高度均低于3.。
由此做出以下推断：
（1）若H(i+1)< H(i)

则 i+1必为以Heigh(i)为高度的矩形面积右边界
（2）若H(i-1)< H(i)

则i-1必为以Heigh(i)为高度的矩形面积左边界
那么基于以上规律
若H(i)> H(i-1)，则将i放入存储空间，i=i+1,循环直至H(i-1)>H(i),此时，i必为H(i-1)的右边界，依次弹出存储空间中的索引=index,直至Heigh(index)< Heigh(i-1),此时的index为i-1的左边界，求出以Heigh(i-1)为高，i-index-1为宽的矩形面积并更新最大面积。
对于存储空间，我们选择 栈。
以下为操作流程：
（1）当直方的高度高于栈顶位置的高度，必知栈顶位置矩形为当前直方的左边界，此刻无法得知右边界，除了讲当前直方压入栈，我们什么都不做；

栈中只存放矩形的下标
（2）当前直方高度小于栈顶矩形高度时：根据总结规律（1）知，当前直方为栈顶矩形的右边界，此时，以栈顶矩形高度为高，依次弹栈，直至找到栈中某一index，使Heigh(index)小于栈顶矩形的高度（或栈为空）并作为左边界；

当i为3时，Heigh(3)< Heigh(s.top=2),此时弹出栈顶的2，index=2；
（3）index=2，高度为4的矩形，宽度为1的矩形面积为4，并更新最大面积；

将索引为2，高度为4的矩形弹出栈后，可以视作[1-2]的矩形如上图所示，因为高度为4的矩形此时若不是最大面积，则之后也不会是，继续比较Heigh(3)

MAX_Size(Heigh)
{
    len=length(Heigh);
    Heigh(len)=0;//为保证所有元素参与循环，在数组最后加0，不会
                 //影响最大面积
    stack.init;//初始化栈
    max_s=0;
    for(i=0;i<len;i++)
    {
        H_cur=Heigh(i);
        if(stack.empty()||H_cur>=Heigh(stack.top()))
        {
            stack.push(i);
        }
        else
        {
            while(H_cur<Heigh(stack.top())&&!stack.empty())
            {
                index=stack.top();
                H=Heigh(index);
                W=stack.empty()?i:i-stack.top()-1;
                max_s=max(max_s,H*W);
            }
        }
    }

}

最后，基于以上伪代码并将其改进后，C++实现如下：

#include "stdafx.h"

#include "stack"


using namespace std;

void Max_size(int Heigh[],int len)
{
    Heigh[len]=0;
    stack<int> Stack;
    int max_s=0;
    int H_cur=0;
    int i=0;

    while (i<=len)
    {
        H_cur=Heigh[i];
        if (Stack.empty()||Heigh[i]>=Heigh[Stack.top()])
        {
            Stack.push(i);
            i+=1;
        }
        else
        {
            if (!Stack.empty()&&Heigh[i]<Heigh[Stack.top()])
            {
                int ind= Stack.top();
                Stack.pop();
                int H=Heigh[ind];
                int W=Stack.empty()?i:i-Stack.top()-1;
                max_s=max(max_s,H*W);

            }
        }

    }
    printf("%d\n",max_s);

}

int _tmain(int argc, _TCHAR* argv[])
{
    int Heigh[6]={2,1,3,3};
    Max_size(Heigh,4);
    return 0;
}