單調棧，顧名思義就是說棧內的元素，按照某種方式排序下，必須是單調的。如果新入棧的元素破壞了單調性，就彈出棧內元素，知道滿足單調性。

它可以很方便地求出某個數的左邊或者右邊第一個比它大或者小的元素，而且總時間複雜度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 100005
pair<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>