单调栈：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的那一天的跨度。

1. 75一直到前面的60都是ok的，80不满足条件，所以跨度=5-2+1=5-1=4（第5天75，第2天60）
2. 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天）股票价格比过去相邻且连续的某些天的股票价格要大（或相等），我们就可以把之前那些天的价格全扔了，之后就不用统计了。

这是因为，若

1. 第y天的价格≥第x天的价格，y>x。那么第y天的价格一定大于被扔掉的那些天的价格
2. 第y天的价格<第x天的价格，y>x。那么在统计第y天的跨度时，无论它和被扔掉的那些天的价格比较的结果如何，它至少会卡在第x天上。换个说法，它根本就没资格和之前被扔掉的那些天的价格作比较。

由上述1，2的分析，我们就可以放心地把在第x天之前并且和第x天相邻且连续的所有不如第x天价格的天数全部都扔了。

这样的操作带来了两个特性：

1. 先进后出
   1. 记录的数据加在最上面
   2. 扔掉的数据从上面开始
2. 单调减
   1. 记录当日价格时会把之前≤当日价格的数据扔掉，不可能出现某两个记录，在下面的记录的价格反而小于在上面的记录的价格。

这样的数据结构称为单调栈。

流程图：

• 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<int[]> stack;
    int idx;
    public StockSpanner() {
        stack = new ArrayDeque<int[]>();
        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<int[]> stack = new ArrayDeque<int[]>();
        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<Integer> stk = new Stack<>();
        stk.push(n-1);
        for(int i=n-2;i>=0;i--){
            while(!stk.isEmpty() && heights[stk.peek()]<heights[i]){
                stk.pop();
                ans[i]++;
            }
            ans[i] += (stk.isEmpty()?0:1);
            stk.push(i);
        }
        return ans;
    }
}

4. LC 1475 商品折扣后的最终价格

单调栈入门板子。从后向前遍历，维护严格单增单调栈。每次遇到比自己大的就踢掉，因此最后栈里面剩下来的元素中，越靠近栈顶，就越靠近左边，越靠近栈底，就越靠近右边，也越小。如果栈不为空，那么就可以减掉栈顶对应的折扣了。

import java.util.Stack;

class Solution {
    public int[] finalPrices(int[] prices) {
        Stack<Integer> stk = new Stack<Integer>();
        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]<stk.peek()){
                stk.pop();
            }
            ans[i] = prices[i];
            if(!stk.isEmpty()){
                ans[i] -= stk.peek();
            }
            stk.push(prices[i]);
        }
        return ans;
    }
}

5. LC 496 下一个更大元素Ⅰ

这道题数据小暴力不会T，但是如果要求O(m+n)的复杂度呢？

从后往前遍历，维护单调栈，如果栈顶的比自己小就踢出去，然后更新自己的下一个最大值（维护一个数组）。最终自己入栈。

这样就能保证每次查询栈顶的时候，一定是离自己最近的更大值（不可能更小，因为更小的都被踢了，不可能更远，因为在栈顶）

import java.util.Arrays;
import java.util.Stack;

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        int[] ans = new int[nums1.length];
        Stack<Integer> stk = new Stack<>();
        int[] next = new int[(int)1e4+5];
        Arrays.fill(next,-1);

        for(int i=nums2.length-1;i>=0;i--){
            while(!stk.isEmpty() && nums2[i]>stk.peek()){
                stk.pop();
            }
            next[nums2[i]] = stk.isEmpty()?-1:stk.peek();
            stk.push(nums2[i]);
        }

        for (int i = 0; i < nums1.length; i++) {
            ans[i] = next[nums1[i]];
        }

        return ans;
    }
}

6. LC 962 最大宽度坡

大致思路是：将更小的数组元素作为检查的锚点。

具体来讲，对于下标i,j,k，如果有A[i] ≤ A[j] ，且i<j，又有A[j] ≤ A[k] ，且j<k，那么答案只可能是k-i而非j-i。这个i相对于j来说就是更小的数组元素，被作为检查点。

在求解答案时，由于想要的是最大距离，因此倒着遍历，对于每一个遍历的下标i，将检查点检查到无可再查的地步，也就是nums[i] <nums[stk.peek()]的程度。不必担心会对下一轮遍历到的前方的索引产生影响，因为如果下一轮也大于这一轮的某些检查点，由于倒着遍历，它的距离不会更大。

import java.util.Stack;

class Solution {
    public int maxWidthRamp(int[] nums) {
        // 将更小的元素A[i]作为检查点 否则，如果A[k] >= A[j] ，那么一定有A[k] >= A[i] 而 i < j，故可以省略k和j的比较
        Stack<Integer> stk = new Stack<>();

        for (int i = 0; i < nums.length; i++) {
            if(stk.isEmpty() || nums[i] <= nums[stk.peek()]){
                stk.push(i);
            }
        }

        int ans = 0;
        // 因为求最大距离，所以倒着检查
        for(int i=nums.length-1;i>=0;i--){
            // 由于由远到近检查 因此一直检查到并不>=栈顶元素的时刻
            while(!stk.isEmpty() && nums[i] >= nums[stk.peek()]){
                ans = Math.max(ans,i-stk.pop());
            }
        }

        return ans;
    }
}

7. LC 1019 链表中的下一个更大节点

这题就是把LC 496题改成了在链表中回溯。注意题目没有给长度n，可以深搜直到底部的时候用递归基中的索引号建立ans数组，以此卡常节省时间。

import java.util.Arrays;
import java.util.Stack;

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    Stack<Integer> stk;
    int[] ans;
    public int[] nextLargerNodes(ListNode head) {
        stk = new Stack<>();
        dfs(head,0);
        return ans;
    }

    private void dfs(ListNode node,int index){
        if(node==null){
            ans = new int[index];
            return;
        }
        dfs(node.next,index+1);
        while(!stk.isEmpty() && node.val >= stk.peek()){
            stk.pop();
        }
        if(!stk.isEmpty()){
            ans[index] = stk.peek();
        }
        stk.push(node.val);
    }
}

8. LC 1124 表现良好的最长时间段

这道题和LC 962很像。但是多了个前缀和的部分。

假设劳累的工作日得1分，否则失1分。那么hours数组的前缀和代表了从[0,i]的得分。对于prefix[i]和prefix[j]，i<j，prefix[j] - prefix[i] 代表了 [i,j]的得分，如果>0说明劳累的天数比较多，也就是prefix[j] > prefix[i]。

之后这道题就转换为了：在已知前缀和的情况下，求max(i-j)，且prefix[j] > prefix[i]。这样就变成了LC 962了。

import java.util.Stack;

class Solution {
    public int longestWPI(int[] hours) {
        Stack<Integer> stk = new Stack<>();
        int[] prefix = new int[hours.length+1];
        stk.push(0);
        for (int i = 1; i < prefix.length; i++) {
            prefix[i] = prefix[i-1] + (hours[i-1]>8?1:-1);
            if(prefix[stk.peek()]>prefix[i]){
                stk.push(i);
            }
        }

        // 逆序找最远距离
        int ans = 0;
        for(int i=prefix.length-1;i>=0;i--){
            while(!stk.isEmpty() && prefix[stk.peek()]<prefix[i]){
                ans = Math.max(ans,i-stk.pop());
            }
        }

        return ans;
    }
}

9. LC 1793 好子数组的最大分数

这个定义其实就是矩形的面积，min()是高度，(j-i+1)是宽度。

对于任意一个高度nums[p]，怎么求它的宽度，使得矩形面积最大呢？

左边界：在p左侧的小于nums[p]的最近下标l

右边界：在p右侧的小于nums[p]的最近下标r

这是因为，如果小于，说明把nums[p]浪费了，就不可能是最大。

以上两个问题都可以由单调栈求解。

矩形宽度(r-l-1)，别忘了r和l都不取。

遍历left,right，要求left[i]和right[i]包含k，也即l<k&&r>k

import java.util.ArrayDeque;

class Solution {
    public int maximumScore(int[] nums, int k) {
        int n = nums.length;
        int[] left = new int[n];
        int[] right = new int[n];

        ArrayDeque<Integer> stk = new ArrayDeque<>();

        for (int i = 0; i < n; i++) {
            int x = nums[i];

            while(!stk.isEmpty()&&x<=nums[stk.peek()]){
                stk.pop();
            }

            left[i] = stk.isEmpty()?-1:stk.peek();

            stk.push(i);
        }

        stk.clear();

        for (int i = n-1; i >= 0; i--) {
            int x = nums[i];

            while(!stk.isEmpty()&&x<=nums[stk.peek()]){
                stk.pop();
            }

            right[i] = stk.isEmpty()?n:stk.peek();

            stk.push(i);
        }

        int l,r,h;
        int ans = 0;
        for (int i = 0; i < n; i++) {
            h = nums[i];
            l = left[i];
            r = right[i];

            if(l<k&&r>k){
                ans = Math.max(ans,h*(r-l-1));
            }
        }

        return ans;

    }
}

10. LC 1673 找出最具竞争力的子序列

最具竞争力的子序列是要找出和上一个元素贴的最紧的元素（第一个元素是在前n-k+1个元素中选个最小的），可以单调栈维护。

如果当前的这个比栈顶的小，那么可以把栈顶的踢掉，直到栈顶的比较小，随后把这个加入栈中。

需要注意的是，我们要保证踢掉的不能太多，否则最后凑不满k个了。

因此每次查询当前元素后还有多少个元素，假设还有t个元素，那么t+1+栈中元素的数量要>k才能踢掉栈顶元素：

from typing import List
import copy

class Solution:
    def mostCompetitive(self, nums: List[int], k: int) -> List[int]:
        stk = []

        i = 0
        while i < len(nums):
            while len(stk) > 0 and nums[i] < stk[len(stk)-1] and (len(nums)-i) + len(stk) > k:
                stk.pop()
            
            if len(stk) < k:
                stk.append(nums[i])
            i += 1
        
        return stk

其中：

(len(nums)-i) + len(stk) > k

是可以优化计算的，我们可以认为可以用来被踢的数量是n-k个，然后每踢一个就少一个，踢没了就不能再踢了。

from typing import List

class Solution:
    def mostCompetitive(self, nums: List[int], k: int) -> List[int]:
        stk = []

        i = 0
        remain = len(nums) - k
        while i < len(nums):
            while len(stk) > 0 and nums[i] < stk[len(stk)-1] and remain>0:
                stk.pop()
                remain -=1
            
            stk.append(nums[i])
            i += 1
        
        return stk[:k]

复杂度O(n)