[杂记]算法: 单调栈

0. 引言

单调栈, 顾名思义就是从栈底到栈顶元素单调递增或者单调递减的栈. 往往, 我们在解决寻找一个元素前面/后面的最远/最近处满足某条件的另一个元素的时候可以用到单调栈.

也是用两道算法题作为例子. 在这之前, 先简单写一下构造单调栈的模板.

如果我们需要从一个数组中组成一个单调栈, 不妨设从栈底到栈顶的元素逐级增加, 代码为:

stack<T> stk;

for (T item: arr) {
	if (stk.empty() || stk.top() < item)
		stk.push(item);
}

1
2
3
4
5
6
7

也就是单调栈提取了数组中的单调元素的规律, 而将不符合该规律的元素排除在外.

1. 表现良好的最长时间段

题目链接: LeetCode1124

这道题是说, 给定一个数组, 例如[9,9,6,0,6,6,9], 找到一个连续子数组, 使得这个子数组里大于8的元素要比小于等于8的元素多.

分析一下这个问题, 如果一个区间, 一开始有4个大于8的元素, 但后面跟了一个小于8的元素, 这时候一共有三个大于8的元素, 还是满足条件的, 因此, 这有点类似于计算函数与坐标轴围成面积大于0的感觉.

因此如果这个元素大于8, 则会施加一个正影响; 小于等于8, 则会施加一个负影响. 我们将其转换为由1, -1组成的数组, 大于8的时候记为1, 小于等于8记为-1, 有:
[1, 1, -1,-1,-1,-1,1]

所以我们要在这个新数组里, 找到和大于0的最长的子区间(和大于0表示大于8的比不大于8的元素多), 这种子区间和的问题我们考虑前缀和数组(前缀和数组的第i个元素$sumArr[i]$表示原数组前$i$个元素的和). 对1, 1, -1,-1,-1,-1,1计算前缀和, 得到:
[0,1,2,1,0,-1,-2,-1]. 因此, 原数组子区间$[i,j]$的和相当于前缀和数组$sumArr[j]-sumArr[i]$的值.

因此问题转化为: 求最大的$j-i$使得$sumArr[j]-sumArr[i]>0$.

因此, 对于前缀和数组的第$j$个元素$sumArr[j]$, 我们需要找到离他最远的, 且比他小的$sumArr[i]$.

这时候我们额外考虑一个问题. 离他最远, 表示$sumArr[i]<sumArr[j]$且$sumArr[i-1](如果有的话)>=sumArr[j]$, 而对于$i,j$中间的数, 我们都不考虑, 因为那不可能是使得这个区间最长的答案. 所以, 我们想维护这样的一个数据结构: 它储存了每一个数组元素$sumArr[j]$满足上述条件的可能的答案, 因此, 我们只需要储存sumArr中递减的那些元素即可. 在寻找最长区间时, 我们对sumArr数组从后往前遍历, 对于遍历到的元素$sumArr[j]$, 我们考察这个数据结构中离他尽可能远的比他小的元素.

因此, 我们维护一个单调栈, 其从栈底到栈顶是递减的, 储存满足严格递减条件的sumArr的下标. 之后从后往前遍历sumArr, 如果栈顶元素小于当前元素$sumArr[j]$, 则出栈, 早晚碰壁(栈顶元素大于等于当前元素), 这时候假设栈顶元素为$k$, 则对于当前元素$sumArr[j]$来说, 满足前述条件的最优匹配就是$k$.

额外说一句为什么小于当前元素的都可以出栈, 是因为即使不出栈, 则继续遍历时, 得到的答案也不可能是最优解, 如图所示:

因此编写代码如下:

class Solution {
public:
    int longestWPI(vector<int>& hours) {
        int result = 0;
        int length = hours.size();

        // 将大于8的元素定义为1, 其余定义为-1
        vector<int> score (length, 0);
        for (int idx = 0; idx < length; ++idx) {
            int sc = hours[idx] > 8 ? 1 : -1;
            score[idx] = sc;
        }

        // 计算前缀和
        vector<int> sumArr (length + 1, 0);
        for (int idx = 1; idx < length + 1; ++idx) 
            sumArr[idx] = sumArr[idx - 1] + score[idx - 1];
    
        /*
        要寻找最大的j - i使得 sumArr[j] - sumArr[i] > 0
        则对于每一个sumArr[k], 只需考察在k之前的最远的比sumArr[k]小的数
        利用单调栈储存
        单调栈从栈底到栈顶是单调递减的 每个元素的意义为原数组中的下标
        */
        stack<int> stk;
        
        for (int idx = 0; idx < length + 1; ++idx) {
            if (stk.empty() || sumArr[stk.top()] > sumArr[idx]) 
                stk.push(idx);
            
        }
        // 倒序遍历sumArr, 寻找当前位置最远的比当前位置小的数的位置 并更新答案
        for (int idx = length; idx > -1; --idx) {
            while(!stk.empty() && sumArr[idx] > sumArr[stk.top()]){
                result = max(result, idx - stk.top());
                stk.pop();
            }
        }

        return result;

    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

2. 柱状图中最大的矩形

这道题与上一题是异曲同工的. 我们考察其中的一个柱状图$heights[i]$, 则我们要考察其左边和右边, 离他最远的比他小的数, 这样才能以他的高度为中心构成一个矩形. 依次枚举$heights$, 更新答案即可.

在考察离某个元素最远且比他小的数, 这又可以用到单调栈, 因此这个题构成两个单调栈, 一个表示某元素左边的比他小的最远数的可能位置, 一个表示右边的比他小的最远数的可能位置, 则面积就是两个位置的差再乘以高度.

该题的单调栈也是从栈底到栈顶单调递减(非严格)的.

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int n = heights.size();
        vector<int> left(n), right(n);  // 储存答案 对于height[i] 最左和
        // 最右的比他小的元素的位置
        
        stack<int> mono_stack;  // 定义栈
        for (int i = 0; i < n; ++i) {
        	// 如果栈顶比当前遍历的值要大于等于 说明这还不是当前元素最远的比它小的
            while (!mono_stack.empty() && heights[mono_stack.top()] >= heights[i]) {
                mono_stack.pop();
            }
            // 找到了 就加入答案
            left[i] = (mono_stack.empty() ? -1 : mono_stack.top());
            mono_stack.push(i);
        }
		
		// 右侧同理
        mono_stack = stack<int>();
        for (int i = n - 1; i >= 0; --i) {
            while (!mono_stack.empty() && heights[mono_stack.top()] >= heights[i]) {
                mono_stack.pop();
            }
            right[i] = (mono_stack.empty() ? n : mono_stack.top());
            mono_stack.push(i);
        }
        
        int ans = 0;
        for (int i = 0; i < n; ++i) {
        	// 计算面积
            ans = max(ans, (right[i] - left[i] - 1) * heights[i]);
        }
        return ans;
    }
};


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38