使用场景
单调栈保证元素是有序的,在序列元素的局部最值处打破循环,此时栈顶的元素即为最值,未入栈的元素和栈顶第二个元素为最值左右两边的元素。
简单的说,单调栈可以寻找元素左边或者右边第一个大于或小于它的值;
抽象一点说,单调栈来寻找左右两边的第一个单调性变化点,这也是后两题的关键
具体题目
每日温度
class Solution {
public:
vector<int> dailyTemperatures(vector<int>& t) {
vector<int> res(t.size());
stack<int> st;
st.push(0);
for (int i = 1; i < t.size(); i++) {
while (!st.empty() && t[i] > t[st.top()]) {
res[st.top()] = i - st.top();
st.pop();
}
st.push(i);
}
while (!st.empty()) {
res[st.top()] = 0;
st.pop();
}
return res;
}
};
正如每日温度这道题,要寻找下一个更大的元素。则单调栈中的元素需保证从栈底到栈顶单调递减;
while (!st.empty() && t[i] > t[st.top()]) {
res[st.top()] = i - st.top();
st.pop();
}
上述核心代码保证了元素单调递减;同时被弹出的元素找到了比该元素本身大的右边第一个元素
下一个更大元素 I
class Solution {
public:
vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
vector<int> res(nums1.size(), -1);
stack<int> st;
unordered_map<int, int> hash;
st.push(0);
for (int i = 1; i < nums2.size(); i++) {
while (!st.empty() && nums2[i] > nums2[st.top()]) {
hash.emplace(nums2[st.top()], nums2[i]);
st.pop();
}
st.push(i);
}
for (int i = 0; i < nums1.size(); i++) {
if (hash.find(nums1[i]) == hash.end()) { continue; }
res[i] = hash[nums1[i]];
}
return res;
}
};
相较于上一题来说, 只需要加入一个哈希表做nums2
和nums2中该元素的下一个元素
的映射
下一个更大元素 II
class Solution {
public:
vector<int> nextGreaterElements(vector<int>& nums) {
vector<int> res(nums.size(), -1);
stack<int> st;
for (int i = 0; i < (nums.size() << 1); i++) {
while (!st.empty() && nums[i % nums.size()] > nums[st.top()]) {
res[st.top()] = nums[i % nums.size()];
st.pop();
}
st.push(i % nums.size());
}
return res;
}
};
相当于循环一个赋值过的有二倍长度的数组,具体处理方法就是在对nums
索引时i % nums.size()
做这样的处理
接雨水
解法一:双指针
class Solution {
public:
int trap(vector<int>& height) {
if (height.size() <= 2) return 0;
vector<int> maxLeft(height.size(), 0);
vector<int> maxRight(height.size(), 0);
int size = maxRight.size();
// 记录每个柱子左边柱子最大高度
maxLeft[0] = height[0];
for (int i = 1; i < size; i++) {
maxLeft[i] = max(height[i], maxLeft[i - 1]);
}
// 记录每个柱子右边柱子最大高度
maxRight[size - 1] = height[size - 1];
for (int i = size - 2; i >= 0; i--) {
maxRight[i] = max(height[i], maxRight[i + 1]);
}
// 求和
int sum = 0;
for (int i = 0; i < size; i++) {
int count = min(maxLeft[i], maxRight[i]) - height[i];
if (count > 0) sum += count;
}
return sum;
}
};
用两个数组分别记录每个位置左右两边第一个大于该元素的值
解法二:单调栈
class Solution {
public:
int trap(vector<int>& h) {
stack<int> st;
st.push(0);
int res = 0;
for (int i = 1; i < h.size(); i++) {
while (!st.empty() && h[i] > h[st.top()]) {
auto mid = st.top();
st.pop();
if (!st.empty()) {
auto hei = min(h[st.top()], h[i]) - h[mid];
res += (i - st.top() - 1) * hei;
}
}
st.push(i);
}
return res;
}
};
首先需要
将栈中元素保持单调递减。当遇见nums[i]
大于nums[st.top()]
时,说明有了拐点,如图
将最小值pop()
,记录好红色部分的值后,继续比较,直至元素呈递减
如果遇见nums[i]
等于nums[st.top]
;需要保证的是两个相邻相等的元素在一块的话,索引值大的应该作为凹槽的左边界
想上述代码一样将nums[i]
等于nums[st.top]
的情况合并到nums[i]
小于nums[st.top]
,背后的原因是以两个(或多个)靠近左边的元素为左边界的情况,得到的凹槽的值为0,即min(h[st.top()], h[i]) - h[mid]
的值为零。
弹出后的情况如下
柱状图中最大的矩形
class Solution {
public:
int largestRectangleArea(vector<int>& heights) {
vector<int> minLeftIndex(heights.size());
vector<int> minRightIndex(heights.size());
int size = heights.size();
// 记录每个柱子 左边第一个小于该柱子的下标
minLeftIndex[0] = -1; // 注意这里初始化,防止下面while死循环
for (int i = 1; i < size; i++) {
int t = i - 1;
// 这里不是用if,而是不断向左寻找的过程
while (t >= 0 && heights[t] >= heights[i]) t = minLeftIndex[t];
minLeftIndex[i] = t;
}
// 记录每个柱子 右边第一个小于该柱子的下标
minRightIndex[size - 1] = size; // 注意这里初始化,防止下面while死循环
for (int i = size - 2; i >= 0; i--) {
int t = i + 1;
// 这里不是用if,而是不断向右寻找的过程
while (t < size && heights[t] >= heights[i]) t = minRightIndex[t];
minRightIndex[i] = t;
}
// 求和
int result = 0;
for (int i = 0; i < size; i++) {
int sum = heights[i] * (minRightIndex[i] - minLeftIndex[i] - 1);
result = max(sum, result);
}
return result;
}
};
解法二:单调栈
class Solution {
public:
int largestRectangleArea(vector<int>& heights) {
stack<int> st;
heights.insert(heights.begin(), 0); // 数组头部加入元素0
heights.push_back(0); // 数组尾部加入元素0
st.push(0);
int result = 0;
for (int i = 1; i < heights.size(); i++) {
while (heights[i] < heights[st.top()]) {
int mid = st.top();
st.pop();
int w = i - st.top() - 1;
int h = heights[mid];
result = max(result, w * h);
}
st.push(i);
}
return result;
}
};
在数组头部尾部加上0,解决数组单调的极端情况
代码部分来源:代码随想录