力扣单调栈算法专题训练

已于 2024-01-05 21:23:21 修改
阅读量553 收藏 7
点赞数 9
分类专栏： 力扣刷题 C++学习 文章标签： leetcode 算法
于 2023-12-22 23:49:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YMWM_/article/details/135161702
版权

目录

1 专题说明

本博客用来计算力扣上的单调栈题目、解题思路和代码。

单调栈题目记录：

  1. 2866美丽塔II
  2. 496下一个更大元素I
  3. 503下一个更大元素II
  4. 2454下一个更大元素IV
  5. 456题132模式
  6. 739每日温度
  7. 901股票价格跨度
  8. 1019链表中的下一个更大节点
  9. 1124表现良好的最长时间段
  10. 1475商品折扣后的最终价格
  11. 2289使数组按非递减顺序排列
  12. 1944队列中可以看到的人数

2 训练

题目1：2866美丽塔II。

解题思路：先计算出prefix[i]，表示0~i满足递增情况下，0~i上的元素之和最大值。然后计算出suffix[i]，表示i~n-1满足递增情况下，i~n-1上的元素之和最大值。那么以i为峰顶的美丽塔的元素之和的最大值为prefix[i] + suffix[i] - nums[i]，遍历i，获得答案即可。

本质上，还是可以归类为：找到i左边，并且<=nums[i]的元素值。

C++代码如下，

class Solution {
public:
    long long maximumSumOfHeights(vector<int>& maxHeights) {
        int n = maxHeights.size();
        vector<long long> prefix(n, 0); //prefix[i]表示0~i是递增的情况下，0~i的元素之和
        stack<int> stk;
        for (int i = 0; i < n; ++i) {
            while (!stk.empty() && maxHeights[stk.top()] > maxHeights[i]) {
                stk.pop();
            }
            if (stk.empty()) {
                prefix[i] = (long long)(i + 1) * maxHeights[i];
            } else {
                prefix[i] = prefix[stk.top()] + (long long)(i - stk.top()) * maxHeights[i];
            }
            stk.push(i);
        }

        while (!stk.empty()) {
            stk.pop();
        }

        vector<long long> suffix(n, 0); //suffix[i]表示i~n-1是递减的情况下，i~n-1的元素之和
        for (int i = n - 1; i >= 0; --i) {
            while (!stk.empty() && maxHeights[stk.top()] > maxHeights[i]) {
                stk.pop();
            }
            if (stk.empty()) {
                suffix[i] = (long long)(n - i) * maxHeights[i];
            } else {
                suffix[i] = suffix[stk.top()] + (long long)(stk.top() - i) * maxHeights[i];
            }
            stk.push(i);
        }

        long long res = 0;
        for (int i = 0; i < n; ++i) {
            res = max(res, prefix[i] + suffix[i] - maxHeights[i]);
        }
        return res;
    }
};

python3代码如下，

class Solution:
    def maximumSumOfHeights(self, maxHeights: List[int]) -> int:
        n = len(maxHeights)
        prefix = [0 for i in range(n)] #0~i的递增数组的和的最大值
        stk = []
        for i in range(n):
            while len(stk) and maxHeights[stk[-1]] > maxHeights[i]:
                del stk[-1]
            if len(stk) == 0:
                prefix[i] = (i + 1) * maxHeights[i]
            else:
                prefix[i] = prefix[stk[-1]] + (i - stk[-1]) * maxHeights[i]
            stk.append(i)
        
        stk.clear()
        suffix = [0 for i in range(n)] #i~n-1的递减数组的和的最大值
        for i in range(n-1,-1,-1):
            while len(stk) and maxHeights[stk[-1]] > maxHeights[i]:
                del stk[-1]
            if len(stk) == 0:
                suffix[i] = (n - i) * maxHeights[i]
            else:
                suffix[i] = suffix[stk[-1]] + (stk[-1] - i) * maxHeights[i]
            stk.append(i)
        
        res = 0
        for i in range(n):
            #print(f"i = {i}, prefix[i] = {prefix[i]}, suffix[i] = {suffix[i]}.")
            res = max(res, prefix[i] + suffix[i] - maxHeights[i])
        return res

题目2：496下一个更大元素I。

解题思路：直接找右边首次大于它的元素即可。

C++代码如下，

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int,int> mp; //mp[x]表示nums2中元素x的右边，第一个比它大的元素
        stack<int> stk;
        for (int i = nums2.size() - 1; i >= 0; --i) {
            while (!stk.empty() && stk.top() <= nums2[i]) {
                stk.pop();
            }
            if (!stk.empty()) {
                mp[nums2[i]] = stk.top();
            } else {
                mp[nums2[i]] = -1;
            }
            stk.push(nums2[i]);
        }

        vector<int> res;
        for (auto x : nums1) {
            res.emplace_back(mp[x]);
        }
        return res;
    }
};

python3代码如下，

class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
        n = len(nums2)
        mp = collections.defaultdict(int)
        stk = []
        for i in range(n - 1, -1, -1):
            while len(stk) and stk[-1] <= nums2[i]:
                del stk[-1]
            if len(stk):
                mp[nums2[i]] = stk[-1]
            else:
                mp[nums2[i]] = -1
            stk.append(nums2[i])
        
        res = []
        for x in nums1:
            res.append(mp[x])
        return res

题目3：503下一个更大元素II。

解题思路：环形问题，扩展两倍原数组即可，接下来就是找右侧首次大于它的元素。

C++代码如下，

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        int n = nums.size();
        vector<int> a(2 * n, 0);
        for (int i = 0; i < n; ++i) {
            a[i] = a[i + n] = nums[i];
        }

        vector<int> ans(2 * n, -1);
        stack<int> stk;
        for (int i = 2 * n - 1; i >= 0; --i) {
            while (!stk.empty() && stk.top() <= a[i]) {
                stk.pop();
            }
            if (!stk.empty()) {
                ans[i] = stk.top();
            }
            stk.push(a[i]);
        }

        vector<int> res(n, -1);
        for (int i = 0; i < n; ++i) {
            res[i] = ans[i];
        }
        return res;
    }
};

python3代码如下，

class Solution:
    def nextGreaterElements(self, nums: List[int]) -> List[int]:
        n = len(nums)
        a = [-1 for i in range(2 * n)]
        for i in range(n):
            a[i] = a[i + n] = nums[i]

        ans = [-1 for i in range(2 * n)]
        stk = []
        for i in range(2 * n - 1, -1, -1):
            while len(stk) and stk[-1] <= a[i]:
                del stk[-1]
            if len(stk):
                ans[i] = stk[-1]
            stk.append(a[i])
        
        res = [-1 for i in range(n)]
        for i in range(n):
            res[i] = ans[i]
        return res

题目4：2454下一个更大元素IV。

解题思路：比较难，不懂先放一边。

题目5：456题132模式。

解题思路：找到右边第一个大于等于它的元素，记录弹出栈的元素的最大值k，如果k > nums[i]，返回true。这思路比较难想到。

C++代码如下，

class Solution {
public:
    bool find132pattern(vector<int>& nums) {
        //找到右边第1个大于等于它的数
        int n = nums.size();
        stack<int> stk;
        int k = INT_MIN;

        for (int i = n - 1; i >= 0; --i) {
            if (k > nums[i]) return true;
            while (!stk.empty() && stk.top() < nums[i]) {
                k = max(k, stk.top());
                stk.pop();
            }
            stk.push(nums[i]);
        }

        return false;
    }
};

python3代码如下，

class Solution:
    def find132pattern(self, nums: List[int]) -> bool:
        #找到右边第一个大于等于它的元素
        n = len(nums)
        stk = []
        k = -1e9
        for i in range(n - 1, -1, -1):
            if k > nums[i]:
                return True 
            
            while len(stk) and stk[-1] < nums[i]:
                k = max(k, stk[-1])
                del stk[-1]
            
            stk.append(nums[i])
        return False

题目6：739每日温度。

解题思路：找到右边比它大的数的下标。

C++代码如下，

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        //找到右边比它大数的下标
        int n = temperatures.size();
        vector<int> res(n, 0);

        stack<int> stk;
        for (int i = n - 1; i >= 0; --i) {
            while (!stk.empty() && temperatures[stk.top()] <= temperatures[i]) {
                stk.pop();
            }
            if (!stk.empty()) {
                res[i] = stk.top() - i;
            }
            stk.push(i);
        }

        return res;
    }
};

python3代码如下，

class Solution:
    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
        #找到右边比它大的数的下标
        n = len(temperatures)
        res = [0 for i in range(n)]
        
        stk = []
        for i in range(n - 1, -1, -1):
            while len(stk) and temperatures[stk[-1]] <= temperatures[i]:
                del stk[-1]
            if len(stk):
                res[i] = stk[-1] - i 
            stk.append(i)
        
        return res

题目7：901股票价格跨度。

解题思路：左边大于它的数的下标。

C++代码如下，

class StockSpanner {
public:
    StockSpanner() {
        //左边大于它这个数的下标
        i = 0;
        while (!stk.empty()) {
            stk.pop();
        }
        return;
    }
    
    int next(int price) {
        int res = 1;
        while (!stk.empty() && stk.top().second <= price) {
            stk.pop();
        }

        if (!stk.empty()) {
            res = i - stk.top().first;
        } else {
            res = i + 1;
        }
        
        stk.push(make_pair(i, price));
        
        i += 1;
        return res;
    }
private:
    int i = 0;
    stack<pair<int,int>> stk;

};

python3代码如下，

class StockSpanner:

    def __init__(self):
        self.i = 0
        self.stk = []
        return


    def next(self, price: int) -> int:
        res = 1
        while len(self.stk) and self.stk[-1][1] <= price:
            del self.stk[-1]
        
        if len(self.stk):
            res = self.i - self.stk[-1][0]
        else:
            res = self.i + 1
        
        self.stk.append([self.i, price])
        self.i += 1

        return res

题目8：1019链表中的下一个更大节点。

解题思路：找到右边第一个比它大的数。

C++代码如下，

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    vector<int> nextLargerNodes(ListNode* head) {
        //右边第一个比它大的值
        vector<int> nums;
        ListNode *node = head;
        while (node != nullptr) {
            nums.emplace_back(node->val);
            node = node->next;
        }

        int n = nums.size();
        vector<int> res(n, 0);
        stack<int> stk;
        for (int i = n - 1; i >= 0; --i) {
            while (!stk.empty() && stk.top() <= nums[i]) {
                stk.pop();
            }
            if (!stk.empty()) {
                res[i] = stk.top();
            }
            stk.push(nums[i]);
        }
        return res;
    }
};

python3代码如下，

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def nextLargerNodes(self, head: Optional[ListNode]) -> List[int]:
        nums = []
        node = head 
        while node is not None:
            nums.append(node.val)
            node = node.next 
        
        n = len(nums)
        res = [0 for i in range(n)]
        stk = []
        for i in range(n-1,-1,-1):
            while len(stk) and stk[-1] <= nums[i]:
                del stk[-1]
            if len(stk):
                res[i] = stk[-1]
            stk.append(nums[i])
        
        return res

题目9：1124表现良好的最长时间段。

解题思路：暂时没有理解，先跳过。

题目10：1475商品折扣后的最终价格。

解题思路：右边第一个小于等于它的数。

C++代码如下，

class Solution {
public:
    vector<int> finalPrices(vector<int>& prices) {
        //下一个小于等于它的数
        int n = prices.size();
        vector<int> res = prices;

        stack<int> stk;
        for (int i = n - 1; i >= 0; --i) {
            while (!stk.empty() && stk.top() > prices[i]) {
                stk.pop();
            }
            if (!stk.empty()) {
                res[i] -= stk.top();
            }
            stk.push(prices[i]);
        }
        return res;
    }
};

python3代码如下，

class Solution:
    def finalPrices(self, prices: List[int]) -> List[int]:
        #右边第一个小于等于它的数
        res = copy.deepcopy(prices)
        n = len(res)

        stk = []
        for i in range(n-1,-1,-1):
            while len(stk) and stk[-1] > prices[i]:
                del stk[-1]
            if len(stk):
                res[i] -= stk[-1]
            stk.append(prices[i])
        
        return res

题目11：2289使数组按非递减顺序排列。

解题思路：还未仔细研究。

题目12：1944队列中可以看到的人数。

解题思路：手推性质。

3 参考

acwing算法基础之数据结构–栈、单调栈、队列和单调队列

YMWM_
关注
  • 9
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
力扣算法思维导图.emmx
08-04
导图内容看这里: https://blog.csdn.net/weixin_43959833/article/details/119389231 导图里面有群号, 添加后会不断更新导图, 提供永久更新服务,用mindmaster打开导图
力扣刷题c++贪心算法.zip
最新发布
04-25
贪心算法 一般来说，贪婪算法有五个组成部分: 一个候选集：从中创建一个解决方案 一个选择函数：用于选择要添加到解决方案中的最佳候选项 一个可行性函数：用于确定候选项是否可以为解决方案做出贡献 一个目标函数...
C#实现力扣双周赛算法题：以组为单位订音乐会的门票订购
06-14
C#实现力扣双周赛算法题：以组为单位订音乐会的门票订购 还有python实现的算法
力扣算法资源11111
04-15
力扣算法资源11111
力扣算法-互联网公司常见算法面试题
03-02
力扣算法-互联网公司常见算法面试题
C++中的reverse()函数
热门推荐
YMWM_的博客
04-06 6万+
实现翻转数组，字符串，向量！ 1翻转数组 //头文件 #include <algorithm> //使用方法 reverse(a, a+n);//n为数组中的元素个数 示例代码， #include <iostream> #include <algorithm> using namespace std; void MyShow(int a[], int n) { for(int i = 0; i < n; i++) cout <&l
结构体排序的三种方式
YMWM_的博客
03-23 1万+
结构体排序方法
C++中如何查询map中是否存在某个元素
YMWM_的博客
04-06 9471
//1 利用count #include <unordered_map> unordered_map<string, int> dist; dist.count(x) == 1;//x元素存在 dist.count(x) == 0;//x元素不存在 //2 利用find dist.find(x) != dist.end();//x元素存在 dist.find(x) == dist.end();//x元素不存在 //3 利用迭代器遍历 unordered_map<string,
c++保留两位有效数字和保留小数点后两位
YMWM_的博客
04-30 4205
  演示代码如下： #include <iostream> #include <iomanip> using namespace std; int main() { double a = 123.345; cout << "正常输出为：" << a << endl; cout << "保留两位有效数字：" << setprecision(2) << a <&
C++中计算迭代器之间的距离 distance
YMWM_的博客
08-20 3360
C++中计算迭代器之间的距离 distance
C++判断两个double数相等不能用==
YMWM_的博客
08-29 2603
  浮点数在内存中的存储有舍入误差，在计算机中用近似表示任意某个实数。比如， double val1 = 4.0; double val2 = 0.1; double a = val1 - val2; 你认为a应该等于3.9，实际在计算机中它却是3.899999999999999999999。   所以不能用==来判断两个double是否相等，而是， const double eps = 1e-8; if(abs(a-b) <= eps) 相等 else 不相等 ...
使用哈希表统计数组中数字出现的次数
YMWM_的博客
02-25 2589
#include <iostream> #include <map> using namespace std; int main() { int array[11] = {1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5}; map<int, int, less<int>> hash; //less表示该哈希表中小数字的次数，再存放大数字的次数。在此处就是，现存放数组中1出现的次数，在存放数
C++中负数的二进制表示
YMWM_的博客
02-23 2571
比如字符型-5，它的二进制表示如下， 第1步：先写出整型5的二进制表示【0000,0101】 第2步：取反加1就是整型-5的二进制表示【1111,1011】
C++中减等于的使用
YMWM_的博客
12-14 1998
x -= a - b; 等价于， x = x - a + b;
C++中的逗号表达式
YMWM_的博客
12-14 1886
int x = (1,2,3,4); 逗号表达式的值等于最后一项的值，上述等价于， int x = 4;
std::thread介绍
YMWM_的博客
06-16 1750
  C++中的一个类， 待更新…
C++ copy函数
YMWM_的博客
11-06 1728
C++ copy函数
C++代码库cppsqlite3使用技巧
YMWM_的博客
06-06 1672
C++代码库cppsqlite3使用技巧
acwing算法基础之搜索与图论--kruskal算法
YMWM_的博客
11-11 1582
kruskal算法
力扣里面哪些题考的是单调栈
05-25
单调栈是一种常用的数据结构，用于解决一类求 Next Greater Element（下一个更大元素）问题，包括以下一些力扣题目： 1. 739. 每日温度（Medium） 2. 496. 下一个更大元素 I（Easy） 3. 503. 下一个更大元素 II...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

YMWM_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值