单调栈：General
1. LC 901.股票价格跨度
题面：
设计一个算法收集某些股票的每日报价，并返回该股票当日价格的 跨度 。
当日股票价格的 跨度 被定义为股票价格小于或等于今天价格的最大连续日数（从今天开始往回数，包括今天）。
- 例如，如果未来 7 天股票的价格是
[100,80,60,70,60,75,85]，那么股票跨度将是[1,1,1,2,1,4,6]。
实现 StockSpanner 类：
StockSpanner()初始化类对象。int next(int price)给出今天的股价price，返回该股票当日价格的 跨度 。
示例：
输入：
["StockSpanner", "next", "next", "next", "next", "next", "next", "next"]
[[], [100], [80], [60], [70], [60], [75], [85]]
输出：
[null, 1, 1, 1, 2, 1, 4, 6]
解释：
StockSpanner stockSpanner = new StockSpanner();
stockSpanner.next(100); // 返回 1
stockSpanner.next(80); // 返回 1
stockSpanner.next(60); // 返回 1
stockSpanner.next(70); // 返回 2
stockSpanner.next(60); // 返回 1
stockSpanner.next(75); // 返回 4 ，因为截至今天的最后 4 个股价 (包括今天的股价 75) 都小于或等于今天的股价。
stockSpanner.next(85); // 返回 6
思路分析：
现在假设我们先要统计第5天（索引从0开始），也就是价格为75的那一天的跨度。然后统计第6天，也就是价格为85的那一天的跨度。
- 75一直到前面的60都是ok的，80不满足条件，所以跨度=5-2+1=5-1=4（第5天75，第2天60）
- 85一直到前面80都是ok的，100不满足条件，所以跨度=6-1+1=6-0=6
观察一下，可以发现85重复统计了第2到第4天（60，70，60）的数据，但实际上，如果我们明确知道了85≥75时，就可以复用75的统计，也就是自动筛掉(60,70,60)这组数据了。
但75和80本身不在75的统计中，所以85在统计时还是要算上这俩的。
也就是说如果我们统计了某一天的跨度，发现当日（假设第x天）股票价格比过去相邻且连续的某些天的股票价格要大（或相等），我们就可以把之前那些天的价格全扔了，之后就不用统计了。
这是因为，若
- 第y天的价格≥第x天的价格，y>x。那么第y天的价格一定大于被扔掉的那些天的价格
- 第y天的价格<第x天的价格，y>x。那么在统计第y天的跨度时，无论它和被扔掉的那些天的价格比较的结果如何，它至少会卡在第x天上。换个说法，它根本就没资格和之前被扔掉的那些天的价格作比较。
由上述1，2的分析，我们就可以放心地把在第x天之前并且和第x天相邻且连续的所有不如第x天价格的天数全部都扔了。
这样的操作带来了两个特性：
- 先进后出
- 记录的数据加在最上面
- 扔掉的数据从上面开始
- 单调减
- 记录当日价格时会把之前≤当日价格的数据扔掉，不可能出现某两个记录，在下面的记录的价格反而小于在上面的记录的价格。
这样的数据结构称为单调栈。
流程图：
- 6 85
5 75(drc 6,85)4 60(drc1 5 75)3 70(drc2 5,75)2 60(delte when record 3 70)- 1 80
- 0 100
注意扔掉的时机
代码实现：
class StockSpanner {
Deque stack;
int idx;
public StockSpanner() {
stack = new ArrayDeque();
idx = -1;
stack.push(new int[]{-1,Integer.MAX_VALUE}); //哨兵
}
public int next(int price) {
idx++;
while(price>=stack.peek()[1]){
stack.pop();
}
int res = idx - stack.peek()[0];
stack.push(new int[]{
idx,price
});
return res;
}
}
/**
* Your StockSpanner object will be instantiated and called as such:
* StockSpanner obj = new StockSpanner();
* int param_1 = obj.next(price);
*/
注意为了peek时不为null，加个哨兵{-1,+∞}。
2. LC 739/LCR 038.每日温度
题面：
给定一个整数数组 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]
代码实现：
class Solution {
public int[] dailyTemperatures(int[] temperatures) {
Deque stack = new ArrayDeque();
int n = temperatures.length;
stack.push(
new int[]{
n,Integer.MAX_VALUE
}
);
int[] ans = new int[n];
for(int i=n-1;i>=0;i--){
while(temperatures[i]>=stack.peek()[1]){
stack.pop();
}
ans[i] = stack.peek()[0]==n?0:stack.peek()[0]-i;
stack.push(
new int[]{
i,temperatures[i]
}
);
}
return ans;
}
}
3. LC 1944 队列中可以看到的人数
少有的我能做出来的hard哈（
这题意思就是，对于任意两个人，如果中间有更高的挡着他俩中的任何一个，那就看不见，否则就能看见。
维护一个单调减的栈（栈顶最小），从右往左检查。如果当前的人比栈顶更高，就让他把栈顶的人踢掉，每踢掉一个，就可以多看见一个人（因为这个人比他矮）。
那可能会担心，万一被踢的这个人右边没有更高的呢，那不就看不见吗，类似于
[ 4,3,2,1]
这是不用担心的，4是不可能把2踢出去的，因为2是被3踢出去的（
如果踢完了之后栈仍不为空，那么栈中最右侧的那个人也能被当前这个人看到，要+1；否则当前这个人就是遍历到现在最高的人，看不到更右边的人。
import java.util.Arrays;
import java.util.Stack;
class Solution {
public int[] canSeePersonsCount(int[] heights) {
int n = heights.length;
int[] ans = new int[n];
Arrays.fill(ans,0);
Stack stk = new Stack<>();
stk.push(n-1);
for(int i=n-2;i>=0;i--){
while(!stk.isEmpty() && heights[stk.peek()] 4. LC 1475 商品折扣后的最终价格
单调栈入门板子。从后向前遍历，维护严格单增单调栈。每次遇到比自己大的就踢掉，因此最后栈里面剩下来的元素中，越靠近栈顶，就越靠近左边，越靠近栈底，就越靠近右边，也越小。如果栈不为空，那么就可以减掉栈顶对应的折扣了。
import java.util.Stack;
class Solution {
public int[] finalPrices(int[] prices) {
Stack stk = new Stack();
int n = prices.length;
int[] ans = new int[n];
ans[n-1] = prices[n-1];
stk.push(prices[n-1]);
for(int i=n-2;i>=0;i--){
while(!stk.isEmpty() && prices[i]