單調棧：

定義：用棧結構來實現，使得遍歷陣列中棧頂元素保持一定範圍的最大或最小，並且棧中元素始終保持單調性的棧。

功能：用以快速（O（n））求出陣列中某連續子集中的最大值或者最小值。

原理：

以求某連續子集中的最小值為例：

假設某陣列為：

模擬過程：

棧頂下標表示當前元素為從此下標到 上一個棧頂下標的最小值。

1.棧為空，將3的下標壓入棧中。                                                           //當前棧狀態：（棧底 0）1                （棧頂）

2.元素1 <= 3，所以3的下標出棧，1的下標入棧。                             //當前棧狀態：（棧底 0）2                （棧頂）

3.元素1 < 6，6的下標入棧。                                                             //當前棧狀態：（棧底 0） 2  3           （棧頂） 此時表示6為 2 + 1 到 3 的最小值。

4.元素4 <= 6，6的下標出棧，1 < 4，4的下標入棧。                       //當前棧狀態：（棧底0）2 4              （棧頂） 此時表示4為 2 + 1 到 4的最小值。

5.元素4 < 5，5的下標入棧。                                                             //當前棧狀態：（棧底0）2 4 5          （棧頂） 此時表示5為 4 + 1 到 5的最小值。

6.元素2 < 5， 5的下標出棧，2<4,4的下標出棧，2的下標入棧。   //當前棧狀態：（棧底0）2 6              （棧頂） 此時表示2為 2 + 1 到 6的最小值。

7.更新完畢。

整個過程，每出棧一次記錄一次，就可以記錄下整個過程中某個連續子段的最小值，達到了其功能。

以下為例題。

poj 2796：

題意：

1e6的資料向量，求連續的子集的和與子集中最小的數的積的最大值， 並求出這段子集的左右座標。

解析：

不造為啥用stack的stl錯了，用陣列的過了。

這題有兩個注意的點，一個是開始ans置為-1，不然會wa的很慘很慘，因為ans = 0 的時候也更新ansL， ansR。

另一個就是要把-1的節點插入到陣列最後，以便單調棧遍歷完整個陣列。

棧頂為當前的最小值。

程式碼：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <stack>
#include <vector>
#include <queue>
#include <map>
#include <climits>
#include <cassert>
#define LL long long
#define lson lo, mi, rt << 1
#define rson mi + 1, hi, rt << 1 | 1

using namespace std;
const int maxn = 1e5 + 10;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const double pi = acos(-1.0);
const double ee = exp(1.0);

LL a[maxn];
LL sum[maxn];
int s[maxn];

int main()
{
#ifdef LOCAL
    freopen("in.txt", "r", stdin);
#endif // LOCAL
    int n;
    while (~scanf("%d", &n))
    {
        memset(sum, 0, sizeof(sum));
        for (int i = 1; i <= n; i++)
        {
            scanf("%lld", &a[i]);
            sum[i] += sum[i - 1] + a[i];
        }
        a[++n] = -1;///debug
        LL ans = -1;///debug
        int ansL = -1, ansR = -1;
        int top = 0;
        for (int i = 1; i <= n; i++)
        {
            while (top && a[i] <= a[s[top]])
            {
                LL t = a[s[top]] * (sum[i - 1] - sum[s[top - 1] + 1 - 1]);
                if (ans < t)
                {
                    ans = t;
                    ansL = s[top - 1] + 1;
                    ansR = i - 1;
                }
                top--;
            }
            s[++top] = i;
        }
        printf("%lld\n%d %d\n", ans, ansL, ansR);
    }
    return 0;
}

poj 2559：

題意：

如上圖，給一些寬度為1的矩形的高度，求由矩形圍成的大矩形的最大面積。

資料量1e5。

解析：

找每個範圍中的最小高度，此時這個最小高度作為整個範圍的高，計算面積，掃一遍取最大面積即可。

往前掃一遍，後掃一遍，相當於記錄當前這個點a[i]在哪個區域內始終是最小的。

注意的是後掃的時候，要將棧頂置為-1，否則後掃時棧值無法置為n+1。

比如 5 0 0 0 0 1，這組資料。

程式碼：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <stack>
#include <vector>
#include <queue>
#include <map>
#include <climits>
#include <cassert>
#define LL long long
#define lson lo, mi, rt << 1
#define rson mi + 1, hi, rt << 1 | 1

using namespace std;
const int maxn = 1e5 + 10;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const double pi = acos(-1.0);
const double ee = exp(1.0);

LL a[maxn];
int s[maxn];//stack
int pre[maxn];
int las[maxn];

int main()
{
#ifdef LOCAL
    freopen("in.txt", "r", stdin);
#endif // LOCAL
    int n;
    while (~scanf("%d", &n) && n)
    {
        memset(s, 0, sizeof(s));
        for (int i = 1; i <= n; i++)
        {
            scanf("%lld", &a[i]);
        }
        int top = 0;
        a[0] = -1;
        for (int i = 1; i <= n; i++)
        {
            while (top && a[i] <= a[s[top]])
            {
                top--;
            }
            pre[i] = s[top];
            s[++top] = i;
        }
        top = 0;
        s[top++] = n + 1;
        a[n + 1] = -1;
        for (int i = n + 1; i >= 1; i--)
        {
            while (top && a[i] <= a[s[top]])
            {
                top--;
            }
            las[i] = s[top];
            s[++top] = i;
        }
        LL ans = 0;
        for (int i = 1; i <= n; i++)
        {
//            cout << pre[i] << " " << las[i] << endl;
            LL t = (las[i] - pre[i] - 1) * a[i];
            if (ans < t)
                ans = t;
        }
        printf("%lld\n", ans);
    }
    return 0;
}

題目：

Description

Mike is the president of country What-The-Fatherland. There are n bears living in this country besides Mike. All of them are standing in a line and they are numbered from1 ton from left to right.i-th bear is exactlya_i feet high.

A group of bears is a non-empty contiguous segment of the line. The size of a group is the number of bears in that group. The strength of a group is the minimum height of the bear in that group.

Mike is a curious to know for each x such that1 ≤ x ≤ n the maximum strength among all groups of sizex.

Input

The first line of input contains integer n (1 ≤ n ≤ 2 × 10⁵), the number of bears.

The second line contains n integers separated by space,a₁, a₂, ..., a_n (1 ≤ a_i ≤ 10⁹), heights of bears.

Output

Print n integers in one line. For each x from 1 to n, print the maximum strength among all groups of size x.

Sample Input

10
1 2 3 4 5 4 3 2 1 6

6 4 4 3 3 2 2 1 1 1 

題意：

給n個數，找到長度為1 ~ n 的子集中，每個子集中元素的最小值，然後取代表每個子集的最小值的最大值。

解析：

如上題一樣，前後掃一遍，相減出長度。

然後掃一遍就好啦。

感謝這題讓我認識了單調棧！

這題有個要注意的地方：

所有長度掃完之後要做一個下面的更新：

for (int i = n - 1; i >= 1; i--)
{
    maxValue[i] = max(maxValue[i + 1], maxValue[i]);
}

程式碼：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <stack>
#include <vector>
#include <queue>
#include <map>
#include <climits>
#include <cassert>
#define LL long long
#define lson lo, mi, rt << 1
#define rson mi + 1, hi, rt << 1 | 1

using namespace std;
const int maxn = 2e5 + 10;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const double pi = acos(-1.0);
const double ee = exp(1.0);

int a[maxn];
int pre[maxn], las[maxn];
int maxValue[maxn];

int main()
{
#ifdef LOCAL
    freopen("in.txt", "r", stdin);
#endif // LOCAL
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
    }
    stack<int> s;
    s.push(0);
    for (int i = 1; i <= n; i++)
    {
        while (!s.empty() && a[i] <= a[s.top()])
            s.pop();
        pre[i] = s.top();
        s.push(i);
    }
    stack<int> t;
    t.push(n + 1);
    for (int i = n; i >= 1; i--)
    {
        while (!t.empty() && a[i] <= a[t.top()])
        {
            t.pop();
        }
        las[i] = t.top();
        t.push(i);
    }
    for (int i = 1; i <= n; i++)
    {
//        cout << pre[i] << " " << las[i] << endl;
        int len = las[i] - pre[i] - 1;
        maxValue[len] = max(maxValue[len], a[i]);
    }
    for (int i = n - 1; i >= 1; i--)
    {
        maxValue[i] = max(maxValue[i + 1], maxValue[i]);
    }
    for (int i = 1; i <= n; i++)
    {
        printf("%d ", maxValue[i]);
    }
    return 0;
}