算法学习——LeetCode力扣单调栈篇（739. 每日温度、496. 下一个更大元素 I、503. 下一个更大元素 II、42. 接雨水、84. 柱状图中最大的矩形）

已于 2024-03-31 19:12:51 修改
阅读量909 收藏 27
点赞数 17
分类专栏： LeetCode算法学习 文章标签： 算法 学习 leetcode c++ 职场和发展 c
于 2024-03-30 20:57:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44814825/article/details/137182732
版权

算法学习——LeetCode力扣单调栈篇

在这里插入图片描述

739. 每日温度

739. 每日温度 - 力扣（LeetCode）

描述

给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指对于第 i 天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用 0 来代替。

示例

示例 1:

输入: temperatures = [73,74,75,71,69,72,76,73]
输出: [1,1,4,2,1,1,0,0]

示例 2:

输入: temperatures = [30,40,50,60]
输出: [1,1,1,0]

示例 3:

输入: temperatures = [30,60,90]
输出: [1,1,0]

提示

1 <= temperatures.length <= 105
30 <= temperatures[i] <= 100

代码解析

单调栈

通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，此时我们就要想到可以用单调栈了。

用temperatures = [73, 74, 75, 71, 71, 72, 76, 73]为例来逐步分析，输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。

  • 首先先将第一个遍历元素加入单调栈
    在这里插入图片描述
  • 加入T[1] = 74，因为T[1] > T[0]，而我们要保持一个递增单调栈（从栈头到栈底），所以将T[0]弹出，T[1]加入，此时result数组可以记录了，result[0] = 1，即T[0]右面第一个比T[0]大的元素是T[1]。
    在这里插入图片描述
  • 加入T[2]，同理，T[1]弹出
    在这里插入图片描述
  • 加入T[3]，T[3] < T[2] （当前遍历的元素T[i]小于栈顶元素T[st.top()]的情况），加T[3]加入单调栈。
    在这里插入图片描述
  • 加入T[4]，T[4] == T[3] （当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况），此时依然要加入栈，不用计算距离，因为我们要求的是右面第一个大于本元素的位置，而不是大于等于！
    在这里插入图片描述
  • 加入T[5]，T[5] > T[4] （当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况），将T[4]弹出，同时计算距离，更新result

在这里插入图片描述

  • T[4]弹出之后， T[5] > T[3] （当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况），将T[3]继续弹出，同时计算距离，更新result

在这里插入图片描述
直到发现T[5]小于T[st.top()]，终止弹出，将T[5]加入单调栈
在这里插入图片描述
加入T[6]，同理，需要将栈里的T[5]，T[2]弹出
在这里插入图片描述

  • 同理，继续弹出
    在这里插入图片描述
  • 此时栈里只剩下了T[6]
    在这里插入图片描述
  • 加入T[7]， T[7] < T[6] 直接入栈，这就是最后的情况，result数组也更新完了。
  • 在这里插入图片描述

那result[6] , result[7]怎么没更新啊，元素也一直在栈里。

其实定义result数组的时候，就应该直接初始化为0，如果result没有更新，说明这个元素右面没有更大的了，也就是为0。

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        vector<int> result(temperatures.size(),0);
        stack<int> st;

        st.push(0);

        for(int i=1 ; i<temperatures.size(); i++)
        {
            while( st.empty()==0  &&  temperatures[i] > temperatures[st.top()] )
            {
                result[st.top()] = i - st.top();
                st.pop();
            }
            st.push(i);
        }
        return result;
    }
};

496. 下一个更大元素 I

496. 下一个更大元素 I - 力扣（LeetCode）

nums1 中数字 x 的 下一个更大元素 是指 x 在 nums2 中对应位置 右侧 的 第一个 比 x 大的元素。

描述

给你两个 没有重复元素 的数组 nums1 和 nums2 ，下标从 0 开始计数，其中nums1 是 nums2 的子集。

对于每个 0 <= i < nums1.length ，找出满足 nums1[i] == nums2[j] 的下标 j ，并且在 nums2 确定 nums2[j] 的 下一个更大元素 。如果不存在下一个更大元素，那么本次查询的答案是 -1 。

返回一个长度为 nums1.length 的数组 ans 作为答案，满足 ans[i] 是如上所述的 下一个更大元素 。

示例

示例 1：

输入：nums1 = [4,1,2], nums2 = [1,3,4,2].
输出：[-1,3,-1]
解释：nums1 中每个值的下一个更大元素如下所述：

  • 4 ，用加粗斜体标识，nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。
  • 1 ，用加粗斜体标识，nums2 = [1,3,4,2]。下一个更大元素是 3 。
  • 2 ，用加粗斜体标识，nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。

示例 2：

输入：nums1 = [2,4], nums2 = [1,2,3,4].
输出：[3,-1]
解释：nums1 中每个值的下一个更大元素如下所述：

  • 2 ，用加粗斜体标识，nums2 = [1,2,3,4]。下一个更大元素是 3 。
  • 4 ，用加粗斜体标识，nums2 = [1,2,3,4]。不存在下一个更大元素，所以答案是 -1 。

提示

1 <= nums1.length <= nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 104
nums1和nums2中所有整数 互不相同
nums1 中的所有整数同样出现在 nums2 中

代码解析

和 739 完全一样

  • 739是找每一个点的右边第一个大于点
  • 该题是找部分点（num1）的右边第一个最大点

具体步骤

  • 用map记录num1出现的点
  • 然后和739一样找每一个右边第一个最大值
  • 找到后判断该点是否是num1里面的，是就保存，不是就放弃
  • 此处和739不同，739找到就保存
class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        vector<int> result(nums1.size(),-1);
        stack<int> st;
        unordered_map<int,int> umap;
        for(int i=0 ; i<nums1.size(); i++)
        {
            umap[nums1[i]] = i; 
        }

        // for(auto it:umap) cout<<it.first<<' '<<it.second<<endl;

        st.push(0);
        for(int i=1 ;i<nums2.size();i++)
        {
            while(st.empty()==0 && nums2[i] > nums2[st.top()])
            {
                if(umap.count(nums2[st.top()]) > 0 )
                {
                    int index = umap[nums2[st.top()]];
                    result[index] = nums2[i];
                }
                st.pop();
            }
            
            st.push(i);
           
        }

        return result;
    }
};

503. 下一个更大元素 II

503. 下一个更大元素 II - 力扣（LeetCode）

描述

给定一个循环数组 nums （ nums[nums.length - 1] 的下一个元素是 nums[0] ），返回 nums 中每个元素的 下一个更大元素 。

数字 x 的 下一个更大的元素 是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1 。

示例

示例 1:

输入: nums = [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2；
数字 2 找不到下一个更大的数；
第二个 1 的下一个最大的数需要循环搜索，结果也是 2。

示例 2:

输入: nums = [1,2,3,4,3]
输出: [2,3,4,-1,4]

提示

1 <= nums.length <= 104
-109 <= nums[i] <= 109

代码解析

和496 类似，为循环数组。将num数组扩充两倍连起来即可

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        vector<int> result(nums.size(),-1);
        vector<int> my_nums(nums.begin() , nums.end());
        stack<int> st;
        int indnx;

        // for(auto it:nums) my_nums.push_back(it); //循环插入
        my_nums.insert(my_nums.end(), nums.begin(), nums.end()); //insert插入
        st.push(0);
      
        for(int i=1 ; i<my_nums.size() ;i++)
        {
            while(st.empty()==0 && my_nums[i] > my_nums[st.top()])
            {	
            	//检测是否是第二圈
                if(st.top()>=nums.size()) indnx = st.top() - nums.size();
                else indnx = st.top();
                result[indnx] = my_nums[i];
                st.pop();
            }
            st.push(i);
        }
        return result;

    }
};

42. 接雨水

42. 接雨水 - 力扣（LeetCode）

描述

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

在这里插入图片描述

示例

示例 1：

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。

示例 2：

输入：height = [4,2,0,3,2,5]
输出：9

提示

n == height.length
1 <= n <= 2 * 104
0 <= height[i] <= 105

代码解析

单调栈

在这里插入图片描述
从栈头（元素从栈头弹出）到栈底的顺序应该是从小到大的顺序。

因为一旦发现添加的柱子高度大于栈头元素了，此时就出现凹槽了，栈头元素就是凹槽底部的柱子，栈头第二个元素就是凹槽左边的柱子，而添加的元素就是凹槽右边的柱子。
在这里插入图片描述
遇到相同的元素，更新栈内下标，就是将栈里元素（旧下标）弹出，将新元素（新下标）加入栈中。

例如 5 5 1 3 这种情况。如果添加第二个5的时候就应该将第一个5的下标弹出，把第二个5添加到栈中。

因为我们要求宽度的时候 如果遇到相同高度的柱子，需要使用最右边的柱子来计算宽度。
在这里插入图片描述

单调栈处理逻辑

  • 先将下标0的柱子加入到栈中

  • 然后开始从下标1开始遍历所有的柱子

  • 如果当前遍历的元素（柱子）高度小于栈顶元素的高度，就把这个元素加入栈中，因为栈里本来就要保持从小到大的顺序（从栈头到栈底）。

  • 如果当前遍历的元素（柱子）高度等于栈顶元素的高度，要跟更新栈顶元素，因为遇到相相同高度的柱子，需要使用最右边的柱子来计算宽度。

  • 如果当前遍历的元素（柱子）高度大于栈顶元素的高度，此时就出现凹槽了，如图所示：栈顶和栈顶的下一个元素以及要入栈的三个元素来接水！

  • 在这里插入图片描述

class Solution {
public:
    int trap(vector<int>& height) {
        if(height.size()<=2) return 0;
        stack<int> st;
        int result = 0;
        st.push(0);

        for(int i=1 ; i<height.size() ;i++)
        {
        	//当前柱子比栈顶的小
            if(height[i] < height[st.top()])
                st.push(i);
            //当前柱子和栈顶相等
            else if(height[i] == height[st.top()])
            {
                st.pop();
                st.push(i);
            //当前柱子比栈顶的大，产生了凹陷
            }else if(height[i] > height[st.top()])
            {
                while(st.empty()==0 && height[i] > height[st.top()])
                {
                    int mid = st.top();
                    st.pop();
                    if(st.empty()==0) 
                    {
                        int left = st.top();
                        int right = i;
                        int h = min(height[left] , height[right]) - height[mid];
                        int w = right - left -1;
                        result += h*w;
                    }
                }
                st.push(i);
            }
        }
        return result;
    }
};

84. 柱状图中最大的矩形

84. 柱状图中最大的矩形 - 力扣（LeetCode）

描述

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。

求在该柱状图中，能够勾勒出来的矩形的最大面积。

示例

示例 1:

在这里插入图片描述

输入：heights = [2,1,5,6,2,3]
输出：10
解释：最大的矩形为图中红色区域，面积为 10

示例 2：

在这里插入图片描述

输入： heights = [2,4]
输出： 4

提示

1 <= heights.length <=105
0 <= heights[i] <= 104

代码解析

单调栈

我们可以遍历每根柱子，以当前柱子 i 的高度作为矩形的高，那么矩形的宽度边界即为向左找到第一个高度小于当前柱体 i 的柱体，向右找到第一个高度小于当前柱体 i 的柱体。

  • 和42接雨水类似
    为什么这么说呢，42. 接雨水 (opens new window)是找每个柱子左右两边第一个大于该柱子高度的柱子，而本题是找每个柱子左右两边第一个小于该柱子的柱子。

  • 那么因为本题是要找每个柱子左右两边第一个小于该柱子的柱子，所以从栈头（元素从栈头弹出）到栈底的顺序应该是从大到小的顺序！
    在这里插入图片描述

  • 只有栈里从大到小的顺序，才能保证栈顶元素找到左右两边第一个小于栈顶元素的柱子。

  • 所以本题单调栈的顺序正好与接雨水反过来。

  • 此时大家应该可以发现其实就是栈顶和栈顶的下一个元素以及要入栈的三个元素组成了我们要求最大面积的高度和宽度

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
      
        heights.insert(heights.begin(), 0); // 数组头部加入元素0
        heights.push_back(0); // 数组尾部加入元素
        stack<int> st;
        int result = 0;
        st.push(0);
        for(int i=1 ; i<heights.size() ;i++)
        {
            if( heights[i] > heights[st.top()] ) 
                st.push(i);
            else if(heights[i] == heights[st.top()])
            {
                st.pop();
                st.push(i);
            }
            else 
            {
                while(st.empty()==0 && heights[i] < heights[st.top()] )
                {
                    int mid = st.top();
                    st.pop();
                    if(st.empty()==0)
                    {
                        int left = st.top();
                        int right = i;
                        int sum = (right - left -1) * heights[mid];
                        cout<<left<<' '<<mid<<' '<<right<<' '<<sum<<endl;
                        if(sum > result) result = sum; 
                    }
                }
                st.push(i);   
            }
        }
        return result;
    }
};
拉依达的嵌入式小屋
关注
  • 17
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
linxid#Leetcode_Python#503. 下一个更大元素 II1
07-25
题目：给定一个循环数组（最后一个元素的下一个元素是数组的第一个元素），输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的
asshead123#my-leetcode#栈-739. 每日温度1
07-25
对于温度列表中的每个元素 temperatures[i]，如果栈为空，则直接将 i 进栈，如果栈不为空，则比较栈顶元素 prevIndex 对应的温度 temp
LeetCode：下一个更大元素——单调栈解决 Next Greater Number 问题
小马同学的博客
10-27 390
单调栈解决 Next Greater Number 问题Next Greater Number原始问题解题思路暴力法单调栈法 Next Greater Number原始问题 给你一个数组，返回一个等长数组，对应索引存储着下一个更大的元素，若没有更大元素，就存-1。 例：给你一个数组[2,1,2,4,3],你需要返回数组[4,2,4,-1,-1] 解释：第一个2后面比2大的数是4，1后面比1大的数是2，第二个 2 后面比 2 大的数是 4; 4 后面没有比 4 大的数，填 -1；3 后面没有比 3 大的
代码随想录算法训练营第五十六天(单调栈篇）| LeetCode 739， 496， 503，42，84
Huiwen18的博客
03-01 1025
用栈存放柱子的位置，当每次遍历到的元素大于栈口元素，那么如果存在”凹槽“，那么栈口元素的位置就是凹槽的底部，将其弹出，如果此时栈中还有元素，说明在栈口元素的位置左边有比它高的柱子，凹槽存在，可以计算接到的雨水。：循环每一个元素的下标和值，如果当前温度高于在栈口元素对应的温度，那么就弹出该天数的下标，计算天数，记录到该天数的结果集中，等栈中小于当前温度的日子都被弹出且记录后，再把当前温度的下标记在栈里，来被之后几天的温度查找。，把第一个pop出后，stack便空了，就无法接着计算以第一个数为基准的面积了。
【每日算法】理论：常见AIGC模型； 刷题：力扣单调栈
weixin_47748259的博客
03-17 1187
图像编码器VAE Encoder会将输入的图像转换为低维的Latent特征，而文本信息则会通过CLIP Text Encoder模型进行编码，处理过后的文本信息和图像信息会输入到图像优化模块中，图像优化模块进行优化迭代后，将其输出的低维Latent特征输入回图像解码器（VAE Decoder）中，重建成像素级图。这道题需要分别寻找元素右边和左边的最大元素来计算雨水面积，由于单调栈的作用是寻找一个元素右边或者左边第一个比自己大或者小的元素的位置，所以单调栈保存的标号主要是用来求雨水面积中的行。
LeetCode精讲（1）—— 单调栈有关习题及其变式
jxwd的博客
08-11 2312
看完本节内容，你将收获：一种思想，四个习题（其中三个为LeetCode上Hard难度） 同时，我们将会在文末放上七道LeetCode上有关单调栈的习题，供大家思考提升（并会附上我们推荐的题解）。 我们将采用图片、视频、文字描述的方式来帮助大家理解。 我们的定位是：让没有接触过这块知识的同学也能够轻松看懂。（如需转载，请注明原文出处和作者呦）...
LeetCode力扣刷题——妙用数据结构
指北针_N的博客
11-09 1114
Sequence Containers：维持顺序的容器。Container Adaptors：基于其它容器实现的数据结构。Associative Containers：实现了排好序的数据结构。Unordered Associative Containers，数据结构，C++ STL，数组，栈和队列，优先队列，双端队列，哈希表，多重集合和映射，前缀和与积分图。在刷题时，我们几乎一定会用到各种数据结构来辅助我们解决问题，因此我们必须熟悉各种 数据结构的特点。C++ STL 提供的数据结构包括
算法学习——单调栈
Orange_Wu的博客
10-11 202
84. 柱状图中最大的矩形 给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。 求在该柱状图中，能够勾勒出来的矩形的最大面积。 示例 1: 输入：heights = [2,1,5,6,2,3] 输出：10 解释：最大的矩形为图中红色区域，面积为 10 示例 2： 输入： heights = [2,4] 输出： 4 提示： 1 <= heights.length <=105 0 <= heights[i] <= 104 来源：力扣（Le
代码随想录学习记录——栈与队列篇
FavoriteStar的博客
09-18 396
本文记录了代码随想录中关于栈与队列篇的部分内容，包含多道力扣题目，有其详细解题思路与讲解，以及具体的代码实现。
LeetCode专题：栈和队列（持续更新，已更17题）
清风微浪又何妨的博客
01-10 1253
持续更新LeetCode的栈和队列专题刷题总结，实际少于162+47道，题目分类参考了宫水三叶https://github.com/SharingSource/LogicStack-LeetCode/wiki。
leetcode热题HOT100汇总——java题解已完结撒花
qq_41810415的博客
12-15 3220
为了学习本文捋顺leetcode热题HOT100的汇总 方便自己秋招刷题 仅作刷题笔记使用 感兴趣的小伙伴点一个赞吧。
php-leetcode题解之下一个更大元素.zip
06-13
php php_leetcode题解之下一个更大元素
AlgorithmAndLeetCode#itcharge-LeetCode-Py#0503. 下一个更大元素 II1
07-25
0503. 下一个更大元素 II标签：栈、数组、单调栈难度：中等题目大意给定一个循环数组 nums（最后一个元素的下一个元素是数组的第一个元素）。遍历数组 nu
Rogerspy#LeetCode-Py-1#0503. 下一个更大元素 II1
07-25
0503. 下一个更大元素 II标签：栈、数组、单调栈难度：中等题目大意给定一个循环数组 nums（最后一个元素的下一个元素是数组的第一个元素）。遍历数组 nu
牛客网刷题 | BC118 N个数之和
m0_64000959的博客
06-09 479
目前主要分为三个专栏，后续还会添加： 专栏如下： C语言刷题解析 C语言系列文章 我的成长经历感谢阅读！初来乍到，如有错误请指出，感谢！输入数字N，然后输入N个数，计算这N个数的和。第一行输入一个整数N(0≤N≤50)，第二行输入用空格分隔的N个整数。输出为一行，为第二行输入的“N个整数之和”的计算结果。使用数组的方式 先将用户输入的几个数字分别存起来定义一个变量将它数字的和加起来然后输出 代码 2 ： 输入n个数相加，应该想到循
【排序算法】总结篇
SWsunlight的博客
06-08 940
排序对比
力扣416 分割等和子集 Java版本
最新发布
m0_47066863的博客
06-14 346
然后就可以考虑用0-1背包的思路来解决这个问题，这里元素的值就是当前元素的价值和重量，背包的容量就是子集元素和的一半，最终需要确定这个背包里是否能够正好装进价值为子集和一半的时候。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。找出两个子集，让这两个子集的和相等可以转化思路为：找到一个子集，这个子集的和是子集中所有元素和的一半。解释：数组可以分割成 [1, 5, 5] 和 [11]。输入：nums = [1,5,11,5]输入：nums = [1,2,3,5]
力扣(LeetCode)2731. 移动机器人
10-18
好的，关于力扣2731题，这是一道模拟题，题目描述如下： 机器人在一个无限大小的 XY 网格平面上行走，从点 (0, 0) 处开始出发，面向北方。该机器人可以接收以下三种类型的命令 commands ： - -2 ：向左转 90 度 - -1 ：向右转 90 度 - 1 <= x <= 9 ：向前移动 x 个单位长度 在网格上有一些格子被视为障碍物 obstacles 。第 i 个障碍物位于网格点 obstacles[i] = (xi, yi) 上。 机器人无法走到障碍物上，它将会停留在障碍物的前一个网格方块上，但仍然可以继续尝试进行该路线的其余部分。 返回从原点到机器人所有经过的路径点（坐标为整数）。答案保证在 10^9 以内。 示例 1： 输入: commands = [4,-1,3], obstacles = [] 输出: [[0,0],[0,1],[0,2],[0,3]] 示例 2： 输入: commands = [4,-1,4,-2,4], obstacles = [[2,4]] 输出: [[0,0],[0,1],[0,2],[1,2],[2,2],[2,3],[2,4]] 解题思路： 我们可以用一个变量来表示当前机器人的朝向，然后根据不同的命令进行模拟即可。需要注意的是，如果机器人前方有障碍物，那么它只能停留在障碍物前面一格，不能穿过障碍物。 代码如下：

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

拉依达的嵌入式小屋

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值