单调栈（poj -- 2559）

单调栈，顾名思义就是说栈内的元素，按照某种方式排序下，必须是单调的。如果新入栈的元素破坏了单调性，就弹出栈内元素，知道满足单调性。

它可以很方便地求出某个数的左边或者右边第一个比它大或者小的元素，而且总时间复杂度O(N)。

1. 题目大意：链接

给出一个柱形统计图(histogram), 它的每个项目的宽度是1， 高度和具体问题有关。 现在编程求出在这个柱形图中的最大面积的长方形。

例如： 

<span style="font-size:18px;">7 2 1 4 5 1 3 3</span>

 

7表示柱形图有7个数据，分别是 2 1 4 5 1 3 3， 对应的柱形图如下，最后求出来的面积最大的图如右图所示。

2. 分析：

要想找到里面的最大的面积，一定会有这么一种情况，得出的矩形的高度一定为所包含的某一个高度一致的。所以我们可以对某一个柱子的高度为标准，尽量的向两头扩展，这样就可以找出以它高度为标准的，并包含它本身的最大矩形。然后对每一个柱子都做类似的工作，最后挑出里面最大的矩形。

OK，单从上述所说，一定会有重复的工作，如何剔除重复工作呢？而且什么叫做尽量向两头扩展呢？

重复工作之后再说。先说什么叫尽量向两头扩展。

如：2 1 4 

第一个：2，以2为高度为准，向左右两头扩展，它只能想右扩展，因为1比2低了，就不可能扩展到1了。宽度只有1。

第二个：1，以1为高度为准，向左右两头扩展，向左，因为2比1高可以扩展过去；向右，因为4也高于1所以扩展到4，这样以1为高度的矩形宽为3了；

第三个：4，以4为高度为准，向左右两头扩展，向左，因为4比1、2都高，显然不可以扩展过去，这样以4为高度的矩形宽为1了。

所以要将其扩展过去，必须高度不低于当前扩展点的高度。

所以如果我们从第一个开始计算到第n个，计算到 i 时，如果我们可以快速的找出左边第一个（这里第一的意思是离i最近）比 i 的高度小的，就可以完成了向左扩展的工作，而向右扩展，我们本来就是一直向右走，所以直接扩展。这时候就轮到：单调栈出场了！

一直保持单调递增的栈。

思考刚才的例子：

2进栈，左边无比其小的元素，记录其最左扩展位置为1

1准备进栈，因为其进栈就破坏了单调栈的性质（2>1），这时2要出栈，因为1<2也说明了2不可能向右扩展，出栈，计算以2为准的矩形 2*1，然后1才进栈。1进栈前，发现其前一个元素，既是当前的栈顶2，比1高，而且2的左扩展从位置1开始，所以1也有理由从2的左起始位置开始（注意：2比1高），所以2出栈后，1进栈，其左扩展应为2的左扩展位置1；

4准备进栈，因为4>1直接进栈，其左扩展位置只能为3了。

最后要清空栈：4退栈，以为是最右的了，这此时右扩展只能为3了。左右扩展都为3，即是其本身，矩形为4*1；记录其位置以备后需；

1退栈，最右扩展只能是上一个退栈的元素位置，因为其高度比1高（单调栈的性质），所以利用刚才记录的位置，1的左右扩展就为1，3了，矩形1*3；

3. 具体操作：

建立一个单调递增栈，所有元素各进栈和出栈一次即可。每个元素出栈的时候更新最大的矩形面积。

设栈内的元素为一个二元组（x, y），x表示矩形的高度，y表示矩形的宽度。

如何压栈并更新呢？

① 如果当前元素比栈顶元素大或者栈为空，则直接压栈（x，1）；

② 如果当前元素小于等于栈顶元素，则退栈，直到 当前元素大于栈顶元素或者栈为空时，压栈。

③在退栈的过程中要进行最大面积和累积宽度的更新：

例：

若原始矩形高度分别为2,1,4,5,1,3,3

高度为2的元素进栈，当前栈为（2，1）

高度为1的元素准备进栈，但必须从栈顶开始删除高度大于或等于1的矩形，因为2已经不可能延续到当前矩形。删除（2，1）这个元素之后，更新最大矩形面积为2*1=2，然后把它的宽度1累加到当前高度为1的准备进栈的矩形，然后进栈，当前栈为（1，2）

高度为4的元素进栈，当前栈为（1，2） （4，1）

高度为5的元素进栈，当前栈为（1，2） （4，1） （5，1）

高度为1的元素准备进栈，删除（5，1）这个元素，更新最大矩形面积为5*1=5，把1累加到下一个元素，得到（4，2），删除（4，2），更新最大矩形面积为4*2=8，把2累加到下一个元素，得到（1，4），1*4=4<8，不必更新，删除（1，4），把4累加到当前准备进栈的元素然后进栈，当前栈为（1，5）

高度为3的元素进栈，当前栈为（1，5） （3，1）

高度为3的元素准备进栈，删除（3，1），不必更新，把1累加到当前准备进栈的元素然后进栈，当前栈为（1，5） （3，2）

把余下的元素逐个出栈，（3，2）出栈，不必更新，把2累加到下一个元素，当前栈为（1，7），（1，7）出栈，不必更新。栈空，结束。

最后的答案就是8。

代码1：直接用栈

#include <iostream>#include <stack>#include <cstdio>using namespace std;struct Node{    long long val;    long long len;};stack<Node> s;int main(){    long long temp,Max,n,i,m;    Node q;    while(scanf("%I64d",&n)!=EOF)    {        if(n==0) break;        Max=0;        for(i=0;i<n;i++)        {            scanf("%I64d",&q.val);            q.len=1;            temp=0;            if(s.empty())            {                s.push(q);            }            else if(q.val<=(s.top()).val)            {                while(!s.empty()&&q.val<=(s.top().val))                {                    (s.top()).len+=temp;                    m=(s.top()).val*(s.top()).len;                    if(m>Max) Max=m;                    temp=(s.top()).len;                    s.pop();                }                q.len+=temp;                s.push(q);            }            else                s.push(q);        }        temp=0;        while(!s.empty())        {            (s.top()).len+=temp;            m=(s.top()).val*(s.top()).len;            if(m>Max) Max=m;            temp=(s.top()).len;            s.pop();        }        cout<<Max<<endl;    }}

代码2：用数组模拟栈

#include <iostream><span style="font-size:14px;">#include <cstdio>using namespace std;#define maxn 100005pair<long long,long long> p[maxn];int main(){    long long n,num,k,i,Max,m,prev;    while(scanf("%I64d",&n)!=EOF)    {        if(n==0) break;        Max=0;        scanf("%I64d",&p[0].first);  //first表示高度，second表示宽度        p[0].second=1;        k=0;        for(i=1;i<=n;i++)        {            if(i<n)scanf("%I64d",&num);            else num=-1;            prev=0;            while(k>=0&&num<=p[k].first)            {                p[k].second+=prev;                m=p[k].first*p[k].second;                if(m>Max) {Max=m;}                prev=p[k].second;                k--;            }            if(num!=-1)            {                    p[++k].second=prev+1;                    p[k].first=num;            }        }        printf("%I64d\n",Max);    }    return 0;}</span>