单调栈~~~

最新推荐文章于 2024-09-16 17:46:36 发布
最新推荐文章于 2024-09-16 17:46:36 发布
阅读量744 收藏 9
点赞数 13
文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79347603/article/details/139688874
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

单调栈~~~

介绍

经典问题
求数组中各个元素左侧最近的小于它的数，以及右侧最近的小于它的数。

  • 1.无重复元素：数组中元素从左往右入栈，需要保证栈中元素严格单调递减，即栈低最小，那么在每个元素入栈时，若栈顶元素大于待入栈元素，使栈顶元素出栈，那么栈顶元素的底下元素为栈顶元素的左侧最近的“小于它”的数组元素，使栈顶元素弹出的元素为栈顶元素的右侧最近的“小于它”的数组元素。

  • 2.有重复元素：方法如上，只是多一步，需要倒着遍历一遍，若该元素标记的右侧最近小元素与其相等，那么更改为其“右侧”的“右侧”（左侧无需修正）。

一.经典例题

1.每日温度


https://leetcode.cn/problems/iIQa4I/description/

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& t) {
        int stack[100002],top=0,n=t.size();
        vector<int> ans(n);
        for(int i=n-1;i>=0;i--){
            while(top>0 && t[i]>=t[stack[top-1]]){
                ans[stack[top-1]]= top==1 ? 0 : stack[top-2]-stack[top-1];
                top--;
            }
            stack[top]=i;
            top++;
        }
        while(top>0){
            ans[stack[top-1]]= top==1 ? 0 : stack[top-2]-stack[top-1];
            top--;
        }
        return ans;
    }
};

该题我没有从左到右遍历，而是从从右到左遍历，因为数组有重复值，这样可以避免最后多做一步修正，因为每个数的“右侧最近小于"是准确的无需修正的

2.子数组的最小值之和


https://leetcode.cn/problems/sum-of-subarray-minimums/description/

我们考虑数组中每个元素，考虑其参与到了多少个数组中计算，我们发现数组数等于m(距离其“左侧最近且小于”的元素的长度)*n(距离其“右侧最近且小于等于”的元素的长度))（一边小于，一边小于等于，正好避免了重复元素所造成的重复性，很奇妙吧，think about it~~）

class Solution {
public:
    int sumSubarrayMins(vector<int>& arr) {
        int n=arr.size(),top=0;
        int stack[30001];
        int m[30001][2];
        int mod=1e9+7;
        for(int i=0;i<n;i++){
            while(top>0 && arr[i]<=arr[stack[top-1]]){
                m[stack[top-1]][0]= top==1 ? stack[top-1]+1 : stack[top-1]-stack[top-2];
                m[stack[top-1]][1]= i-stack[top-1];
                top--;
            }
            stack[top]=i;
            top++;
        }
        while(top>0){
            m[stack[top-1]][0]= top==1 ? stack[top-1]+1 : stack[top-1]-stack[top-2];
            m[stack[top-1]][1]= n-stack[top-1];
            top--;
        }
        long long ans=0;
        for(int i=0;i<n;i++){
            ans=(ans+arr[i]*m[i][0]%mod*(long long)1*m[i][1]%mod)%mod;
        }
        return ans;
    }
};

3.柱状图中的最大矩形


https://leetcode.cn/problems/0ynMMM/description/

class Solution {
public:
    int largestRectangleArea(vector<int>& h) {
        int top=0,n=h.size();
        vector<int> stack(n+1);
        int ans=0;
        for(int i=0;i<n;i++){
            while(top>0 && h[i]<=h[stack[top-1]]){
                int x0= top==1 ? stack[top-1]+1 : stack[top-1]-stack[top-2];
                int x1= i-stack[top-1];
                ans=max(ans,(x0+x1-1)*h[stack[top-1]]);
                top--;
            }
            stack[top]=i;
            top++;
        } 
        while(top>0){
            int x0= top==1 ? stack[top-1]+1 : stack[top-1]-stack[top-2];
            int x1= n-stack[top-1];
            ans=max(ans,(x0+x1-1)*h[stack[top-1]]);
            top--;
        }
        return ans;
        
    }
};

4.最大矩形


https://leetcode.cn/problems/PLYXKQ/description/

考虑以每一行为底的矩形，分别算出最大面积，然后取整体最大

class Solution {
public:
    int maximalRectangle(vector<string>& s) {
        int m[201][201];
        int stack[201],top,ans=0;
        int row=s.size();
        if(row==0)return 0;
        int col=s[0].length(); 
        for(int i=0;i<col;i++){
            m[0][i]=s[0][i]-'0';
        }
        for(int i=1;i<row;i++){
            for(int j=0;j<col;j++){
                m[i][j]=(s[i][j]=='0') ? 0 : m[i-1][j]+1;
            }
        }
        for(int i=0;i<row;i++){
            top=0;
            for(int j=0;j<col;j++){
                while(top>0 && m[i][j]<=m[i][stack[top-1]]){
                    int x0= top==1 ? stack[top-1]+1 : stack[top-1]-stack[top-2];
                    int x1= j-stack[top-1];
                    ans=max(ans,(x0+x1-1)*m[i][stack[top-1]]);
                    top--;
                }
                stack[top]=j;
                top++;
            }
            while(top>0){
                int x0= top==1 ? stack[top-1]+1 : stack[top-1]-stack[top-2];
                int x1= col-stack[top-1];
                ans=max(ans,(x0+x1-1)*m[i][stack[top-1]]);
                top--;
            }
        }
        return ans;
    }
};

二.较难例题

1.最大宽度坡


https://leetcode.cn/problems/maximum-width-ramp/description/

class Solution {
public:
    int maxWidthRamp(vector<int>& nums) {
        int n=nums.size(),top=0,ans=0;
        int stack[50001];
        //维护一个严格单调递减的栈，如此一遍可得到所有“最大宽度坡”可能的左侧值。
        for(int i=0;i<n;i++){
            if(top==0 || nums[i]<nums[stack[top-1]])stack[top++]=i;
        }
        //倒序遍历数组，若栈顶元素小于等于所遍历到的元素，出栈，并比较是否更新最大宽度。
        for(int i=n-1;i>=0;i--){
            if(top==0)break;
            while(top>0 && nums[i]>=nums[stack[top-1]]){
                ans=max(ans,i-stack[top-1]);
                top--;
            }
        }
        return ans;
    }
};

2.去除重复字母


https://leetcode.cn/problems/remove-duplicate-letters/description/

class Solution {
public:
    bool set[200];
    char stack[1002];
    int top=0;
    int cnt[200];
    string removeDuplicateLetters(string s) {
        for(auto c:s){
            cnt[c]++;
        }
        for(auto c:s){
            if(!set[c]){
                while(top>0 && c<stack[top-1] && cnt[stack[top-1]]>0){
                    top--;
                    set[stack[top]]=0;
                }
                set[c]=1;
                stack[top++]=c;
            }
            cnt[c]--;
        }
        string ans;
        for(int i=0;i<top;i++){
            ans+=stack[i];
        }
        return ans;
    }
};

3.使数组按非递减顺序排列


https://leetcode.cn/problems/steps-to-make-array-non-decreasing/description/
类似于大鱼吃小鱼
我们从右往左将数组元素依次压入栈内，（保持栈内从顶向下非递减），且记录两个关键量，这个元素的值以及其需要进行吃小鱼的轮数。当待入栈元素大于栈顶元素时，令栈顶元素出栈，且让待入栈元素“接替”栈顶元素的吃鱼任务，故需比较其本身的任务时间与接替的任务时间的大小，取其大者。用此方法直到可入栈。
最后遍历单调栈中元素，得到最长的“任务轮数”


class Solution {
public:
    int totalSteps(vector<int>& nums) {
        int stack[100002][2],top=0;
        int n=nums.size();
        int ans=0;
        for(int i=n-1;i>=0;i--){
            int cnt=0;
            while(top>0 && nums[i]>stack[top-1][0]){
                cnt++;
                cnt=max(cnt,stack[top-1][1]);
                top--;
            }
            stack[top][0]=nums[i];
            stack[top][1]=cnt;
            top++;
        }
        while(top>0){
            ans=max(ans,stack[top-1][1]);
            top--;
        }
        return ans;
    }
};

4.统计全1子矩形

在这里插入图片描述


https://leetcode.cn/problems/count-submatrices-with-all-ones/description/
考虑以每一行为底的全1子矩形数
对每行遍历元素，考虑每个元素时，我们计算好矩形的数量，好矩形——以该元素高度为高度上限，以 左侧最近且比该元素小的高度 和 右侧最近且比该元素小的高度 的 较大值 为高度下限 的矩形。

class Solution {
public:
    int numSubmat(vector<vector<int>>& mat) {
        int m=mat.size(),n=mat[0].size();
        int mem[151][151];
        int stack[151],top=0;
        int ans=0;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                mem[i+1][j]= mat[i][j]==0 ? 0 : mem[i][j]+1;
            }
        }
        for(int i=1;i<=m;i++){
            for(int j=0;j<n;j++){
                while(top>0 && mem[i][j]<=mem[i][stack[top-1]]){
                    int x0= top==1 ? stack[top-1]+1 : stack[top-1]-stack[top-2];
                    int x1= j-stack[top-1];
                    int h1= top==1 ? 0 : mem[i][stack[top-2]];
                    int h2= mem[i][j];
                    int cen=mem[i][stack[top-1]]-max(h1,h2);
                    ans+=(x1+x0-1)*(x1+x0)/2*(cen);
                    top--;
                }
                stack[top]=j;
                top++;
            }
            while(top>0){
                int x0= top==1 ? stack[top-1]+1 : stack[top-1]-stack[top-2];
                int x1= n-stack[top-1];
                int h1= top==1 ? 0 : mem[i][stack[top-2]];
                int h2= 0;
                int cen=mem[i][stack[top-1]]-max(h1,h2);
                ans+=(x1+x0-1)*(x1+x0)/2*(cen);
                top--;
            }
        }
        return ans;
    }
};
隔壁的小公举
关注
优先队列与单调栈~2020.9.12
fatfairyyy的博客
09-12 328
优先队列 引自：洛谷P3378 【模板】堆 #输入 5 1 2 1 5 2 3 2 #输出 2 5 AC代码： #include <iostream> #include <queue> using namespace std; typedef long long ll; priority_queue<ll,vector<int>,greater<int> > q; int main() { ll n; cin>>n; whi
单调栈和单调队列.pdf
06-09
### 单调栈与单调队列详解 #### 一、单调栈 **定义：** 单调栈是一种特殊的数据结构，其内部存储的元素按照单调递增或单调递减的方式排序。当有新的元素需要加入栈时，若这个元素破坏了当前栈内元素的单调性，则...
单调栈~~
weixin_44965579的博客
09-04 111
单调栈
单调栈~~下一个更大的元素
RUN
05-31 167
O(N)时间复杂度解决~~ 左边就从左边开始，如果比上一个小，那么上一个弹出… 右边就从右边开始，如果比上一个大，放入，小也弹出之前的. # 反正记住优先队列就是有进有出~~这么思考 class Solution: def foundMonotoneStack(self , nums ): # write code here # 左边就从左边开始，如果比上一个小，那么上一个弹出... # 右边就从右边开始，如果比上一个大，放入，小也弹出之前的. .
两道题帮你搞定单调栈~
liiiiiiiiii123的博客
03-21 262
（1）439.每日温度 思路：利用栈存首元素后进入循环，若数组[i]比栈顶大，则将他们的差存入新定义的数组，若不大则存入栈等待后面的数据与他进行比较； 代码： （2）下一个更大元素 思路：此题将nums1存入哈希表 代码：
单调栈
热门推荐
少说，多做。
09-15 1万+
通过使用栈这个简单的结构，我们可以巧妙地降低一些问题的时间复杂度。 单调栈性质： 1、若是单调递增栈，则从栈顶到栈底的元素是严格递增的。若是单调递减栈，则从栈顶到栈底的元素是严格递减的。 2、越靠近栈顶的元素越后进栈。（显而易见） 本文介绍单调栈用法 通过一道题来说明。 POJ2559 1. 题目大意：链接 给出一个柱形统计图(histogram), 它的每个项目的宽度是1， 高度...
单调栈模板
拧发条鸟的博客
12-04 849
单调栈 参考文章：单调栈题解秒杀三道算法题 顾名思义，单调栈本质是一个栈。只不过里面的元素是单调递增或者递减的。它的用途不是很广泛，只处理一种叫做Next Greater Element的典型问题。 1. 下一个更大元素 题目描述 给定一个数组，返回一个等长的数组，对应索引存储着下一个更大的元素值。 如果没有更大的元素，返回-1。 这是一个典型的Next Greater Element问题，因此使用单调栈模板来解决。 vector<int> nextGreaterElement(vec
C++ 单调栈
m0_59680769的博客
07-19 882
当题目给出一维数组，且要求我们求出数组元素的左边或者右边第一个比自己大或者比自己小的数组元素的下标或者数组元素本身的时候。注意，这里就有四种情况：左边比自己大，左边比自己小，右边比自己大，右边比自己小。
单调栈-java
m0_63267251的博客
05-05 1265
本次主要通过数组模拟单调栈来解决问题。
单调栈及其应用
**祺的博客
07-31 724
单调栈是一种内部元素具有单调性的栈，可以解决“以某个值为最值的最大区间”等问题。 能以O(n)的时间复杂度找到每一个元素右边或左边第一个比它大或小的数。（超级好用艾~ 不然可能就得用（毒瘤的）二分+RMQ惹QAQ） 1.糟糕的一天（洛谷P2866, USACO 2006 月赛） 2.天气变化 3.长方形（洛谷P1950）......
单调栈 & 单调队列 专题
Mr_dimple的博客
01-05 1412
上述操作通过维护单调递增栈，求出了数列中每个数左边第一个比它小的数。同理可以维护单调递减栈，求出数列中每个数左边第一个比它大的数。将枚举顺序转换，从后往前枚举，便能求出数列中每个数右边第一个比它小/大的数。求区间最小值，维护单调递增栈；求区间最大值，维护单调递减栈。把原理搞懂，能够用代码实现之后，这两种算法就掌握了。在以后的题目中，如果需要求每个位置左边/右边第一个比其大/小的元素，就要想到用单调栈；如果需要维护一个移动区间的最值，用单调队列O(n)O(n)O(n)
神奇的单调栈
10-27
如果你不知道单调栈的应用,那么你就out了!赶快学习一下吧,保证你看的懂!
C++ STL中sort函数
weixin_43349440的博客
09-15 167
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
CF C. Nikita and LCM
qq_74190237的博客
09-13 264
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++与QML的数据交互
qq_50679120的博客
09-11 520
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
【C++】【网络】【Linux系统编程】单例模式，加锁封装TCP/IP协议套接字
2301_79796701的博客
09-16 852
给系统，表明这个套接字所期望的、还未处理的（即还在等待被接受的连接）连接请求的最大队列长度。换句话说，它告诉系统内核为这个套接字分配多大的空间来存储尚未处理的连接请求。有关套接字编程的细节和更多的系统调用课参考《UNIX环境高级编程》一书，可以在如下网站搜索电子版，该书在第16章详细的介绍了各种接口。我们可以根据自己的需求，用面向对象的思想封装出接口简洁的类。在类似添加一个该类类型的指针，该指针是静态的并且是私有成员。结构体填充，为了使不同的地址格式能和套接字绑定，需要把对应的结构体强转成通用地址结构。
C++_map_set详解
最新发布
2302_77644537的博客
09-16 624
set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格的排序准则（默认是小于）进行排序。set在底层是用二叉搜索树(红黑树)实现的。map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 501
继续学习头文件的数学函数。
【C++ && Qt day11】
wzj46的博客
09-11 274
2、头文件窗口文件。
Codeforces单调栈
10-10
单调栈是一种常用的数据结构，用于解决一类特定的问题，其中最常见的问题是找到数组中每个元素的下一个更大或更小的元素。在Codeforces编程竞赛中，单调栈经常被用于解决一些与数组相关的问题。 下面是单调栈的一般思路： 1. 创建一个空栈。 2. 从左到右遍历数组元素。 3. 对于每个元素，将其与栈顶元素进行比较。 - 如果当前元素小于等于栈顶元素，则将当前元素入栈。 - 如果当前元素大于栈顶元素，则将栈顶元素弹出，并将当前元素入栈。 4. 重复步骤3，直到遍历完所有元素。 这样，最后剩下的栈中元素就是没有下一个更大或更小元素的元素。在使用单调栈求解具体问题时，我们可以根据需要进行一些特定的操作。 例如，如果要找到一个数组中每个元素的下一个更大的元素，可以使用单调递减栈。具体操作如下： 1. 创建一个空栈和一个空结果数组。 2. 从左到右遍历数组元素。 3. 对于每个元素，将其与栈顶元素进行比较。 - 如果当前元素小于等于栈顶元素，则将当前元素入栈。 - 如果当前元素大于栈顶元素，则将栈顶元素弹出，并将其在结果数组中的位置记录为当前元素的下一个更大元素的索引。 4. 将当前元素入栈。 5. 重复步骤3和4，直到遍历完所有元素。 6. 结果数组中没有下一个更大元素的位置，可以设置为-1。 以下是一个使用单调递减栈求解下一个更大元素问题的示例代码： ```cpp #include <iostream> #include <stack> #include <vector> std::vector<int> nextGreaterElement(std::vector<int>& nums) { int n = nums.size(); std::vector<int> result(n, -1); std::stack<int> stack; for (int i = 0; i < n; i++) { while (!stack.empty() && nums[i] > nums[stack.top()]) { result[stack.top()] = i; stack.pop(); } stack.push(i); } return result; } int main() { std::vector<int> nums = {1,3, 2, 4, 5, 1}; std::vector<int> result = nextGreaterElement(nums); for (int i = 0; i < result.size(); i++) { std::cout << "Next greater element for " << nums[i] << ": "; if (result[i] != -1) { std::cout << nums[result[i]]; } else { std::cout << "None"; } std::cout << std::endl; } return 0; } ``` 以上代码将输出： ``` Next greater element for 1: 3 Next greater element for 3: 4 Next greater element for 2: 4 Next greater element for 4: 5 Next greater element for 5: None Next greater element for 1: None ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值