单调栈详解

最新推荐文章于 2024-06-23 15:40:24 发布
最新推荐文章于 2024-06-23 15:40:24 发布
阅读量395 收藏
点赞数
分类专栏： 零散知识点 单调栈

 

单调递增或单调减的栈，跟单调队列差不多，但是只用到它的一端，利用它可以用来解决一些ACM/ICPC和OI的题目，如RQNOJ 的诺诺的队列等。

单调栈是一种特殊的栈，特殊之处在于栈内的元素都保持一个单调性。 
假设下图是一个栈内元素的排列情况(单调递增的栈)：

此时插入情况有两种： 
(1).插入元素大于栈顶元素 
当插入7时，因7 > 6，满足单调递增的条件，故可以直接加入栈 
此时： 


(2).插入的元素小于栈顶元素 
当插入3时，为了满足单调递增栈的性质，需要先将栈顶的4，6弹出，再插入，此时：

功能
以上的内容和图我相信是非常容易理解的，但单调栈的作用和功能并不能得到很好的体现，故下面将用文字 + 图示的形式来展示单调栈的作用

先上结论： 
利用单调栈，可以找到从左/右遍历第一个比它小/大的元素的位置

举个例子： 
假设有一个单调递增的栈 S和一组数列： 
a : 5 3 7 4

用数组L[i] 表示 第i个数向左遍历的第一个比它小的元素的位置

如何求L[i]？

首先我们考虑一个朴素的算法，可以按顺序枚举每一个数，然后再依此向左遍历。 
但是当数列单调递减时，复杂度是严格的O(n^2)。

此时我们便可以利用单调栈在O(n)的复杂度下实现

我们按顺序遍历数组，然后构造一个单调递增栈

(1). i = 1时，因栈为空，L[1] = 0，此时再将第一个元素的位置下标1存入栈中

此时栈中情况：

 
(2).i = 2时，因当前3小于栈顶元素对应的元素5，故将5弹出栈 
此时栈为空 
故L[2] = 0 
然后将元素3对应的位置下标2存入栈中

此时栈中情况：

(3).i = 3时，因当前7大于栈顶元素对应的元素3，故 
L[3] = S.top() = 2 (栈顶元素的值)

然后将元素7对应的下标3存入栈 
此时栈中情况：

(4).i = 4时，为保持单调递增的性质，应将栈顶元素3弹出 
此时 L[4] = S.top() = 2;

然后将元素4对应的下标3存入栈 
此时栈中情况：

至此 算法结束 
对应的结果： 
a : 5 3 7 4 
L : 0 0 2 2

总结：一个元素向左遍历的第一个比它小的数的位置就是将它插入单调栈时栈顶元素的值，若栈为空，则说明不存在这么一个数。然后将此元素的下标存入栈，就能类似迭代般地求解后面的元素

代码：

Stack<int> S;
    for(int i=1 ;i<=n ;i++){
        while(S.size() && a[S.top()] >= a[i]) S.pop();

        if(S.empty())     L[i] = 0;
        else              L[i] = S.top();

        S.push(i);
    }
1
2
3
4
5
6
7
8
9
看到这里我相信你一定会有疑问，不知道这个功能有什么作用。 
但其实通过下面的例题你会发现，用好单调栈，我们就可以解决一些看似非常复杂的问题。

例题：
HDU 1506
题目链接：

首先考虑最大面积的矩形X的左右边界的性质：

设其左边界为L，右边界为R，则其高H = min{h[i] | L <= i <= R}

此时最大面积为 (R - L + 1) * H

若此时左边界的左边那个矩形的高度 h[L-1] >= H 
则左边界可以向左拓展，则新的面积为：

(R - (L-1) + 1) * H > 原面积

则与原假设条件冲突

故左边界左边的那个矩形的高度 :h[L-1] < H 
同理右边界右边的那个矩形的高度： h[R+1] < H

设H = h[i]

所以左边界L是满足h[j-1] < h[i]的最大的j，即从i点向左遍历的第一个高度比i小的点的右边一个点

而右边界R是满足 h[j+1] < h[i]的最小的j，即从i点向右遍历第一个高度比i小的点的左边一个点

所以我们可以利用单调栈的性质得到每个确定点，即确定高度的最大面积矩形的左右边界，然后枚举取最大即可。

代码：

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

#define rep(i, a, b)              for(int i(a); i <= (b); ++i)
#define dec(i, a, b)              for(int i(a); i >= (b); --i)
#define MP                        make_pair

const int N = 100000 + 100;

stack<int> S;
ll h[N];
int R[N],L[N];

int main(){
    int n;
    while(~scanf("%d",&n) && n){
        for(int i=0 ;i<n ;i++)  scanf("%I64d",&h[i]);

        while(S.size()) S.pop();

        for(int i=0 ;i<n ;i++){
            while(S.size() && h[S.top()] >= h[i]) S.pop();

            if(S.empty())     L[i] = 0;
            else              L[i] = S.top() + 1;

            S.push(i);
        }

        while(S.size()) S.pop();
        for(int i=n-1 ;i>=0 ;i--){
            while(S.size() && h[S.top()] >= h[i]) S.pop();

            if(S.empty()) R[i] = n;
            else          R[i] = S.top();

            S.push(i);
        }

        ll ans = 0;
        for(int i=0 ;i<n ;i++){
            ans = max(ans,h[i] * (R[i] - L[i]));
        }
        printf("%I64d\n",ans);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
HDU 5033
题目链接

这是北京区域赛的一道题，确实才接触时感觉难度很大，想了两天 加 在网上查看了题解才真正AC。这道题让我对单调栈的理解加深了不少。

题意不难理解，但难在如何利用单调栈的性质快速求解。

之前的想法是一次初始化，二分查询再跳跃式地查找区间左右边界点。 
但奈何复杂度非常高，此题是明显地过不了的。

所以正确需要离线处理，先读入所有的查询，将每个查询点视为高度为0的楼，然后再通过比较两栋相邻楼顶连线的斜率大小维护一个单调栈。

一些细节性的东西网上有很多题解，便不再赘述。

#include<bits/stdc++.h>

using namespace std;

const int A = 100000 + 100;
const double PI = acos(-1.0);
const double eps = 1e-8;

class Build{
public:
    int id;
    double x,h;

    friend bool operator<(Build &a,Build &b){
        return b.x > a.x;
    }
};

Build build[A*2];
double R[2*A],L[2*A];
int S[A*2];
int num,cnt,q,n;

int dcmp(double x){
    return x < -eps ? -1 : x > eps;
}

double f(int i,int j,int type){
    if(type == 1)
        return (build[i].h - build[j].h) / (build[j].x - build[i].x);
    return     (build[j].h - build[i].h) / (build[j].x - build[i].x);
}

inline void solve(){
    cnt = 0;

    for(int i=0 ;i<num ;i++){
       while(cnt >= 2 && f(S[cnt-1],S[cnt],1) - f(S[cnt],i,1) >= 0) {
            cnt--;
       }

        if(build[i].id >= 0){
           if(cnt == 0) L[build[i].id] = 0.0;
           else         L[build[i].id] = atan(f(S[cnt],i,1)) / (2.0*PI) * 360.0;
        }
        S[++cnt] = i;
    }

    cnt = 0;
    for(int i=num-1 ;i >= 0;i--){
       while(cnt >= 2 && f(S[cnt],S[cnt-1],2) - f(i,S[cnt],2) >= 0){
            cnt--;
       }

        if(build[i].id >= 0){
           if(cnt == 0) R[build[i].id] = 0;
           else         R[build[i].id] = atan(f(i,S[cnt],2)) / (2.0*PI) * 360.0;
        }
        S[++cnt] = i;
    }

    for(int i=0 ;i<q ;i++){
        printf("%.10f\n",180.0 - (L[i] + R[i]));
    }
}

int main(){
    int T,_=1;
    scanf("%d",&T);

    while(T--){
        scanf("%d",&n);

        for(int i=0 ;i<n ;i++){
            scanf("%lf%lf",&build[i].x,&build[i].h);
            build[i].id  = -1;
        }

        scanf("%d",&q);
        for(int i=n ;i < n+q ;i++){
            scanf("%lf",&build[i].x);

            build[i].h = 0;
            build[i].id = i - n;
        }

        num = n + q;
        sort(build,build+num);

        printf("Case #%d:\n",_++);
        solve();
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
PKU 2796
题目链接

题意很好理解，但此题不仅要求区间的边界点，还要求区间的和，所以用一个树状数组维护一个区间和即可。 
另外注意全部为一个值和最大值为0的情况。

#include <iostream>
#include<iomanip>
#include <cstdio>
#include <cstdlib>
#include<cstring>
#include <string>
#include <algorithm>
#include <cmath>
#include <cctype>
#include<queue>
#include<map>
#include<stack>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

const int A = 1e5 + 100;
int n,cnt;
int a[A];
int S[A],L[A],R[A];
ll Tree[A];

int lowbit(int x){
    return x & (-x);
}

ll getsum(int pos){
    ll res = 0;
    while(pos >= 1){
        res += Tree[pos];
        pos -= lowbit(pos);
    }

    return res;
}

void add(int pos,int val){
    while(pos <= n){
        Tree[pos] += val;
        pos += lowbit(pos);
    }
}

void solve(){
    cnt = 0;

    for(int i=1 ;i<=n ;i++){
        while(cnt > 0 && a[S[cnt]] >= a[i]) cnt--;

        if(cnt == 0) L[i] = 1;
        else         L[i] = S[cnt] + 1;
        S[++cnt] = i;
        //printf("%d : L = %d\n",i,L[i]);
    }

    cnt = 0;
    for(int i=n ;i>=1 ;i--){
        while(cnt > 0 && a[S[cnt]] >= a[i]) cnt--;

        if(cnt == 0) R[i] = n;
        else         R[i] = S[cnt] - 1;
        S[++cnt] = i;
       // printf("%d : R = %d\n",i,R[i]);
    }

    ll ans = 0;
    int left,right;
    for(int i = 1;i<=n ;i++){
        ll sum = getsum(R[i]) - getsum(L[i]-1);
        sum *= a[i];

        if(sum >= ans){
            left = L[i];
            right = R[i];

            ans = sum;
        }
    }

    printf("%lld\n",ans);
    printf("%d %d\n",left,right);
}

int main(){
    while(~scanf("%d",&n)){
        memset(Tree,0,sizeof(Tree));
        for(int i=1 ;i<=n ;i++){
            scanf("%d",&a[i]);
            add(i,a[i]);
        }
        a[0] = 0;

        solve();
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
PKU 3250
题目链接

很裸的单调栈，而且只需要跑一个方向。 
简单入门题

#include <iostream>
#include<iomanip>
#include <cstdio>
#include <cstdlib>
#include<cstring>
#include <string>
#include <algorithm>
#include <cmath>
#include <cctype>
#include<queue>
#include<map>
#include<stack>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

const int INF = 1e9 + 7;
const int A   = 1e5 + 10;

int a[A],S[A],num[A];
int cnt,n;

void solve(){
    cnt = 0;

    a[n] = INF;
    for(int i=n ;i>=0 ;i--){
        while(cnt>0 && a[S[cnt]] < a[i]) cnt--;

        if(cnt == 0) num[i] = 0;
        else         num[i] = S[cnt] - i - 1;
        S[++cnt] = i;
    }

    ll ans = 0;
    for(int i=0 ;i<n ;i++){
        ans += num[i];
    }
    printf("%I64d\n",ans);
}

int main(){
    scanf("%d",&n);

    for(int i=0 ;i<n ;i++){
        scanf("%d",&a[i]);
    }
    solve();
    return 0;
}
--------------------- 
作者：Wubaizhe 
来源：CSDN 
原文：https://blog.csdn.net/wubaizhe/article/details/70136174 

@萌橙开心
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单调栈练习题题解
This is Mendez.
07-30 2636
单调栈单调栈顾名思义就是让栈中的元素是单调的，要么递增，要么递减。同样它也满足栈的性质，先进后出。 单调递增栈，则从栈顶到栈底的元素是严格递增的 单调递减栈，则从栈顶到栈底的元素是严格递减的 练习题单调栈 练习题 POJ3250 POJ2796 BZOJ1113 HDU1506 POJ2559 JDFZ2997POJ3250POJ3250传送门 对于每一个牛来说，能看到的数目为向右数身高比它小的个
单调栈总结
新熊君的博客
04-11 2万+
单调栈总结目录 定义 性质 功能 例题 HDU 1506 HDU 5033 PKU 2796 PKU 3250 定义性质下面引自百度百科 单调递增或单调减的栈，跟单调队列差不多，但是只用到它的一端，利用它可以用来解决一些ACM/ICPC和OI的题目，如RQNOJ 的诺诺的队列等。 单调栈是一种特殊的栈，特殊之处在于栈内的元素都保持一个单调性。 假设下图是一个栈内元素的排列情况(单调递增的
力扣刷题笔记
最新发布
博客
06-23 1017
力扣刷题记录
浅谈单调栈的实现方式和简单应用
aua4137的博客
02-27 154
一、单调栈的原理和实现方式 1.定义 从栈底元素到栈顶元素呈单调递增或单调递减，栈内序列满足单调性的栈； 2.原理 (1)当新元素在单调性上优于栈顶时（单增栈新元素比栈顶大，单减栈新元素比栈顶小），压栈，栈深+1； (2)当新元素在单调性与栈顶相同（新元素于栈顶相同）或劣于栈顶时（单增栈新元素比栈顶小，单减栈新元素比栈顶大），弹栈，栈深-1； 3.一般实现形式 以单增栈（栈顶为最大值）为...
【算法训练】单调栈相关
GUANYX的博客
05-19 90
前一篇文章中接触了单调栈的问题，今天的题目中也采用了单调栈相关技巧 去除字符串中的重复字符 一、去除重复字母316 1、分析 题目有三个要求 （1）首先要保证每个字母出现的相对顺序和原数组中相同——单调栈保证顺序 （2）然后就要求每个字母在结果中只出现一次——严格控制出现次数 （3）还要保证返回结果的字典序最小——即要保证字典序小的字符要在前面；可以考虑将栈中大于当前元素的内容出栈，然后将当前元素入栈。但是在出栈操作前，还要考虑到每个元素都要出现一次这点，所以就看栈顶元素在后续是否还有出现机会（这里我.
ACM入门之【单调栈】
辉小歌的博客
03-10 235
何为单调栈，顾名思义，单调栈即满足单调性的栈结构。 单调栈解决的问题： 可以找到对于当前位置左边(或右边)最近的大于(或小于)它的值(或者下标)。 常用模板: typedef long long int LL; const int N=1e6+10; LL h[N],lmax[N],rmax[N],n; //lmax[i]左边最近的比它大的数的下标 //rmax[i]右边最近的比它大的数的下标 void init() { stack<int>st; for(int i=1;i&lt.
单调栈和单调队列.pdf
06-09
### 单调栈与单调队列详解 #### 一、单调栈 **定义：** 单调栈是一种特殊的数据结构，其内部存储的元素按照单调递增或单调递减的方式排序。当有新的元素需要加入栈时，若这个元素破坏了当前栈内元素的单调性，则...
前缀和详解21.zip
03-31
在实际编码过程中，前缀和通常与其他算法和数据结构结合使用，如二分查找、滑动窗口、单调栈等，以解决更复杂的问题。例如，当需要找到数组中第一个不满足特定条件的元素时，可以结合单调栈和前缀和来达到O(n)的时间...
前缀和详解22.zip
03-31
在求解最值问题时，配合单调栈或单调队列，可以快速找到最大或最小的连续子数组；在树状数组（ Fenwick Tree ）和线段树等数据结构中，前缀和的概念也被广泛使用，以实现高效的区间更新和查询操作。 此外，前缀和还...
前缀和详解01.zip
03-31
3. **求最大/最小值**：配合单调栈或单调队列，可以找到数组中连续子序列的最大或最小和。 4. **区间加减操作**：在数据结构如区间树、 Fenwick树（也称为Binary Indexed Tree，BIT）中，前缀和被用来实现对数组元素...
动态规划算法详解（ACM编程培训）
08-16
单调队列或者单调栈可以用来加速某些动态规划问题的状态更新过程，例如在处理最值问题时，如果当前状态只与前几个状态有关，且存在单调性，那么可以使用这些数据结构来快速找到需要的前几个状态，从而提升算法效率。...
CodeForces 631 C.Report（单调栈）
ZSQ
04-27 424
Description 给出一个长度为n的序列a，两种操作： 1 x：把前x个数升序排 2 x：把前x个数降序排 问m次操作后的序列 Input 第一行两个整数n和m分别表示序列长度和操作数，之后n个整数ai表示该序列，最后m行每行表示一个操作(1<=n,m<=2e5) Output 输出操作后的序列 Sample Input 3 1 1 2 3 2 2 Sample Ou
单调栈的实现
m0_54625749的博客
01-07 162
830. 单调栈 给定一个长度为 N 的整数数列，输出每个数左边第一个比它小的数，如果不存在则输出 −1。 输入格式 第一行包含整数 N，表示数列长度。 第二行包含 N 个整数，表示整数数列。 输出格式 共一行，包含 N 个整数，其中第 i 个数表示第 i 个数的左边第一个比它小的数，如果不存在则输出 −1。 数据范围 1≤N≤105 1≤数列中元素≤109 输入样例： 5 3 4 2 7 5 输出样例： -1 3 -1 2 2 #include<iostream> using namespa
acm专题学习之单调栈（一）单调栈入门+Max answer
qq_40306845的博客
04-23 388
单调栈： 定义：栈里面保持一种单调性 举例： 栈里面的元素为1，2，5，6（6是栈顶） 插入一个元素7 7大于栈顶元素6，可以直接入栈，此时栈为1，2，5，6，7 插入一个元素4 4小于栈顶元素7，7出栈，栈为1，2，5，6 4小于栈顶元素6，6出栈，栈为1，2，5 4小于栈顶元素5，5出栈，栈为1，2 4大于栈顶元素2，可以直接入栈，此时栈为1，2，4 遇到比栈顶元素大的就直...
单调栈的实现和应用
dtxew love c++
03-19 938
单调栈讲解 问题引入 假设我们这儿有一个数组arr 我们现在想得到数组中任意一个数左边第一个比它小（或大）的下标位置和右边第一个比它小（或大）的下标位置的信息 比如上面的数字6，左边第一个比它小的数字是2，对应下标位置是2右边第一个比它小的数字是1，对应下标位置4，所以能生成以下信息 6:[2,4] 而我们规定，左边或者右边没有比其小的数字的话，把答案设为-1 而我们现在需要每个数字的对应信息，这种问题我们该怎么求解呢？ 很容易想到暴力方法，我们遍历每一个数字，然后把每个数字往左往右遍历一遍查找符合要
单调栈
nameofcsdn的博客
01-28 8601
目录 一，单调栈 二，具体实现 三，应用 1，数组大小关系计算 2，力扣OJ907. 子数组的最小值之和 一，单调栈 单调栈是一种基于栈进行的算法。 场景： 给定一个n个数的数组和一个空栈，依次读取n个数，每个数分别入栈一次，出栈一次，最后仍然是空栈。 在这个过程中，需要保持栈里面的元素从栈顶到栈底一直是单调递增（或递减）的，相应的，按照出栈顺序排列的n个数也是单调递增（或递减）的。 n个数的入栈顺序是原数组顺序，但是出栈顺序就不一定了，这个算法就是用来控制，何时入栈，何时出栈。 .
数据结构之单调栈(含代码实现）
qq_56999918的博客
03-13 2763
1.单调栈的基本概念： 相信大家对栈都非常的熟悉？栈有一个非常鲜明的特点：先进后出 而所谓单调栈则是在栈的先进后出基础之上额外添加一个特性：从栈顶到栈底的元素是严格递增（or递减）。 1.对于单调递增栈，若当前进栈元素为 x，从栈顶开始遍历元素，把大于等于x的元素弹出栈，直接遇到一个小于x的元素或者栈为空为止，然x压入栈中。 2.对于单调递减栈，则每次弹出的是小于x的元素。 以单调递增为例： 以序列：3，2，4，0，1，5 让其从左到右依次入栈： 第一步：将3压入栈中。...
[数据结构]——单调栈
热门推荐
lucky52529的博客
04-09 14万+
单调栈 笔者在做leetcode的题(下一个出现的最大数字)时，接触到了单调栈这一种数据结构，经过研究之后，发现单调栈在解决某些问题时出奇的好用，下面是对单调栈的性质和一些典型题目。 什么是单调栈？ 从名字上就听的出来，单调栈中存放的数据应该是有序的，所以单调栈也分为单调递增栈和单调递减栈 单调递增栈：数据出栈的序列为单调递增序列 单调递减栈：数据出栈的序列为单调递减序列 ps：这里一定要注意...
【Codeforces 631C 】Report（单调栈，思维模拟）
xuanweiace的博客
11-01 442
题干： Each month Blake gets the report containing main economic indicators of the company "Blake Technologies". There are n commodities produced by the company. For each of them there is exactly one in...
单调多边形三角剖分：高效算法详解
这个算法按照y坐标递减的顺序处理顶点，使用栈S作为辅助数据结构，尽可能地在当前顶点和栈中的顶点间添加对角线，形成三角形。 通过将单调多边形的三角剖分与前文提到的多边形分解方法相结合，可以得出结论：任何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值