c++单调栈

单调栈一般用来求下一个最值问题，是LeetCode中常考的算法题。

496. 下一个更大元素 I

给你两个 没有重复元素 的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。

请你找出 nums1 中每个元素在 nums2 中的下一个比其大的值。

nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出 -1 。

//496. 下一个更大元素 I
/*
Next Greater Element问题的求解采用单调栈
单调栈类似于单调队列，只是存储的方式变成了栈，其实现的方式也有固定的模板
思路：
1.从后向前遍历num2，采用单调递增栈来存储数据，记录新增元素小于栈顶元素时的栈顶元素是多少，此值就是next最大值
2.遍历num1输出步骤1中的next最大值
*/
#include <iostream>
#include <stack>
#include <vector>
#include <unordered_map>
using namespace std;

class Solution {
public:
	vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) 
	{
		vector<int> result;
		unordered_map<int, int> umap;//用哈希表来存储next最大值，key是要插入的数值，value是next最大值
		stack<int> st;
		//右边的next最大值从右往前遍历
		for (int i = nums2.size() - 1; i >= 0; i--)
		{
			//直到为空或者找到一个比待插入数值大的数
			while (!st.empty() && st.top() < nums2[i])
				st.pop();
			umap[nums2[i]] = (st.empty() ? -1 : st.top());
			st.push(nums2[i]);
		}

		for (int i = 0; i < nums1.size(); i++)
		{
			result.emplace_back(umap[nums1[i]]);
		}
		return result;
	}
};

int main()
{
	vector<int> nums1{ 4,1,2 };
	vector<int> nums2{ 1,3,4,2 };

	vector<int> res;
	Solution s;
	res = s.nextGreaterElement(nums1, nums2);
	for (auto i : res)
		cout << i << " ";
}

503. 下一个更大元素 II 

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/next-greater-element-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 

//503. 下一个更大元素 II
/*
与上一题的不同是原始数据是循环数组
*/
#include <iostream>
#include <stack>
#include <typeinfo>
using namespace std;
class Solution {
public:
	vector<int> nextGreaterElements(vector<int>& nums) {
		//循环使用，内存开销小点
		stack<int> st;
		int nums_size = nums.size();
		vector<int> result(nums_size);

		//倒序，采用%可循环使用一段空间
		for (int i = 2 * nums_size - 1; i >= 0; i--)
		{
			while (!st.empty() && nums[i%nums_size] >= st.top())
				st.pop();

			result[i%nums_size] = st.empty() ? -1 : st.top();
			st.push(nums[i%nums_size]);
		}

		return result;

#if 0
		//法一，开销大
		stack<int> st;
		int nums_size = nums.size();
		vector<int> result(2*nums_size);
		for (int i = 0; i < nums_size; i++)
			nums.emplace_back(nums[i]);

		//倒序
		for (int i = 2 * nums_size - 1; i >= 0; i--)
		{
			while (!st.empty() && nums[i] >= st.top())
				st.pop();

			result[i] = st.empty() ? -1 : st.top();
			st.push(nums[i]);
		}

		vector<int> res;
		for (int i = 0; i < nums_size; i++)
			res.emplace_back(result[i]);
		return res;
#endif
	}
};

int main()
{
	vector<int> nums{ 1,2,3,4,3 };
	Solution s;
	vector<int> res;
	res = s.nextGreaterElements(nums);
	for (auto i : res)
		cout << i << " ";
}

 84. 柱状图中最大的矩形

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

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

//84. 柱状图中最大的矩形
/*
找到某高度height[i]时其左右两侧的第一个小于它的数值，其中左边界用-1表示，有边界用最大的size表示；
面积=(right-left-1)*height[i]，计算出其最大值即可
解题思路：
来计算当前值其左侧的第一个小于它的数值和其右侧第一个小于它的数值，故采用单调栈。
采用单调递增栈（栈底到栈顶递增）栈中的数据存储的为左右两侧最小值的索引
1、当数值height[i]小于栈顶元素时，则出栈，知道栈为null或者栈顶数值小于该数值height[i]
2、出栈的时候计算右边界，压栈的时候计算左边界
3、计算最大面积即可

以[6, 7, 5]为例说明
left为[-1, 0， -1](到边界或者无最小值时用-1表示)
right为[2, 3, 3];（到边界或者无最小值时用数组的size来表示）
*/
#include <vector>
#include <stack>
#include <algorithm>
using namespace std;
class Solution {
public:
	int largestRectangleArea(vector<int>& heights) 
	{
		int n = heights.size();
		vector<int> left(n);
		vector<int> right(n, n);
		stack<int> st;

		for (int i = 0; i < n; i++)
		{
			while (!st.empty() && heights[st.top()] >= heights[i])
			{
				right[st.top()] = i;
				st.pop();
			}
			left[i] = st.empty() ? -1 : st.top();
			st.push(i);//将当前索引压入栈
		}

		int ans = 0;
		for (int i = 0; i < n; i++)
		{
			ans = max(ans, (right[i] - left[i] - 1)*heights[i]);
		}
		return ans;
	}
};

int main()
{
	vector<int> nums{ 6, 7, 9 };
	Solution s;
	cout<<s.largestRectangleArea(nums);
}
#endif