灵神题单-单调栈（更新中）

单调栈是用来解决一类问题，且只解决这一类问题的

496. 下一个更大元素 I - 力扣（LeetCode）

单调栈【基础算法精讲 26】哔哩哔哩bilibili

模板代码如下：

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {//从左到右遍历的版本
        int n =temperatures.size();
        vector<int> ans(n, 0);
        stack<int> s;
        for(int i=0;i<n;++i) {
            while(!s.empty() && temperatures[i]>temperatures[s.top()]) {//栈不空，且当前元素大于栈顶元素的时候
                ans[s.top()]=temperatures[i];//记录答案
                s.pop();//弹出栈顶元素
            }
            s.push(i);//栈为空或者当前元素小于栈顶元素的时候，入栈
        }
        return ans;
    }
};

所有的题目只是在这个基础之上做一些变化，例如下一个更大温度出现在几天之后，下一个更大元素与当前栈顶的差值再乘以一个数等于多少

---

739. 每日温度 - 力扣（LeetCode）

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        int n =temperatures.size();
        vector<int> ans(n, 0);
        stack<int> s;
        for(int i=0;i<n;++i) {
            while(!s.empty() && temperatures[i]>temperatures[s.top()]) {
                ans[s.top()]=i-s.top();//这道题里，需要记录的是数组中每个值与下一个更大的值的下标之差
                s.pop();
            }
            s.push(i);
        }
        return ans;
    }
};

496. 下一个更大元素 I - 力扣（LeetCode）

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        stack<int> s;
        unordered_map<int, int> hashtable;//这道题的变体稍微复杂点，需要一个哈希表
        for(int i=0; i<nums2.size(); ++i) {
            while(!s.empty() && nums2[i]>nums2[s.top()]) {
                hashtable.insert(pair<int, int>(nums2[s.top()], nums2[i]));//记录下一个更大的值
                s.pop();
            }
            s.push(i);
        }
        while(!s.empty()) {//常规解法在这道题里，会导致栈中仍然有需要的元素，需要将他们对应的值设为-1
            hashtable.insert(pair<int, int>(nums2[s.top()], -1));
            s.pop();
        }
        for(int& i:nums1)//范围遍历for循环需要改变值的时候，要加上 &
            i=hashtable[i];
        return nums1;
    }
};

1475. 商品折扣后的最终价格 - 力扣（LeetCode）

class Solution {
public:
    vector<int> finalPrices(vector<int>& prices) {
        int n=prices.size();
        vector<int> ans(n,0);
        stack<int> s;

        for(int i=0; i<n;++i) {
            while(!s.empty() && prices[i]<=prices[s.top()]) {
                ans[s.top()] = prices[s.top()]-prices[i];//这道题里，需要记录的是数组中每个值与其下一个更小的值之间的差值
                s.pop();
            }
            s.push(i);
            ans[i]=prices[i];
        }

        return ans;
    }
};

503. 下一个更大元素 II - 力扣（LeetCode）

class Solution {//这道题也可以将原数组拉长到 2n 长度来解决
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        int n=nums.size();
        vector<int> ans(n, -1);
        stack<int> s;
        for(int i=0; i<2*n; ++i) {
            while(!s.empty() && nums[i%n]>nums[s.top()]) {//这道题给出的是一个循环数组，在处理下标时取模即可
                ans[s.top()]=nums[i%n];
                s.pop();
            }
            s.push(i%n);
        }
        return ans;
    }
};

1019. 链表中的下一个更大节点 - 力扣（LeetCode）

class Solution {//将链表转换成数组即可用常规做法
public:
    vector<int> nextLargerNodes(ListNode* head) {
        ListNode* temp = head;
        vector<int> nums;
        while(temp) {
            nums.push_back(temp->val);
            temp=temp->next;
        }
        vector<int> ans(nums.size(), 0);
        stack<int> s;
        for(int i=0; i<nums.size(); ++i) {
            while(!s.empty() && nums[i]>nums[s.top()]) {
                ans[s.top()] = nums[i];
                s.pop();
            }
            s.push(i);
        }
        return ans;
    }
};

901. 股票价格跨度 - 力扣（LeetCode）

class StockSpanner {//这题的形式是第一次见，但这道题本身不是很复杂
public:
    vector<int> ans;
    stack<int> s;
    StockSpanner() {
        ans.push_back(INT_MAX);
        s.push(0);
    }
    int next(int price) {
        ans.push_back(price);
        while(price >= ans[s.top()])
            s.pop();
        int res = a.size()-s.top()-1;
        s.push(ans.size()-1);
        return res;
    }
};

962. 最大宽度坡 - 力扣（LeetCode）

class Solution {
public:
    int maxWidthRamp(vector<int>& nums) {
        // 首先，为原数组正向遍历建立单调栈，只存储递减的值，因为如果有 nums[i+1] > nums[i]，那么 i+1 处就肯定不是最终答案，可以扔掉
        stack<int> stk;
        stk.push(0);
        for (int i = 1; i < nums.size(); ++i) {
            if (nums[i] < nums[stk.top()])
                stk.push(i);
        }
	    // 然后，逆向遍历原数组，如果栈顶小于 nums[i]，就出栈，并更新 ans。因为对于栈顶，这就是能得到的最大的 j-i 了
        int ans = -1;
        for (int i = nums.size() - 1; i >= 0; --i) {
            while (!stk.empty() && nums[i] >= nums[stk.top()]) {
                ans = max(ans, i - stk.top());
                stk.pop();
            }
        }
        return ans;
    }
};

456. 132 模式 - 力扣（LeetCode）

class Solution {
public:
    bool find132pattern(vector<int>& nums) {

        int n = nums.size();
        vector<int> l(n, -1), r(n, n);

        int lmin = 0;// 首先从左到右遍历，找出每个元素左边最小的元素
        for (int i = 1; i < n; ++i) {
            if (nums[i] > nums[lmin])
                l[i] = lmin;	// 记录
            else
                lmin = i;
        }

        stack<int> stk;	// 然后从右到左遍历，维护一个单调递减的栈，在出栈的过程中，得到每个元素右边小于该元素值的最大的一个元素值
        for (int i = n - 1; i >= 0; --i) {
            int temp = n;	// 需要一个临时变量将 stk.top() 存起来
            while (!stk.empty() && nums[i] > nums[stk.top()]) {
                temp = stk.top();
                stk.pop();
            }
            r[i] = temp;	// 记录
            stk.push(i);
        }

        for (int i = 1; i < n - 1; ++i) {	// 得到结果
            if (l[i] != -1 && r[i] != n && l[i] < i && i < r[i] && nums[l[i]] < nums[r[i]] && nums[r[i]] < nums[i])
                return true;
        }
        return false;
    }
};

下面是标准答案，虽然都是 O(n) 的时间复杂度，但这个答案更简洁一些，只需一次遍历

class Solution {
public:
    bool find132pattern(vector<int>& nums) {
        stack<int> stk;
        int n = nums.size(), k = INT_MIN;
        for (int i = n - 1; i >= 0; --i) {
            while (!stk.empty() && nums[i] > nums[stk.top()]) {
                k = max(k, nums[stk.top()]);	// 元素出栈废弃之前，使用出栈元素维护 k 值
                stk.pop();
            }
            if (nums[i] < k)	// 由于 k 值必然小于栈顶元素，此时如果又有 k 大于即将入栈的元素，则满足题意
                return true;
            stk.push(i);
        }
        return false;
    }
};

84. 柱状图中最大的矩形 - 力扣（LeetCode）

这题思路是这样的：每一个可能作为答案的矩形，它的高度一定是某个柱子的高度，它的长度则是，它左边第一个小于它的元素，与它右边第一个小于它的元素，之间的下标的差。因此，只需两个单调栈即可。

class Solution {
public:
    int largestRectangleArea(vector<int>& nums) {
        int ans = 0, n = nums.size();
        vector<int> l(n, -1), r(n, n);
        stack<int> stk;
        for (int i = n - 1; i >= 0; --i) {
            while (!stk.empty() && nums[i] < nums[stk.top()]) {
                l[stk.top()] = i;
                stk.pop();
            }
            stk.push(i);
        }
        stk = stack<int>();
        for (int i = 0; i < n; ++i) {
            while (!stk.empty() && nums[i] < nums[stk.top()]) {
                r[stk.top()] = i;
                stk.pop();
            }
            stk.push(i);
        }
        for (int i = 0; i < n; ++i)
            ans = max(ans, nums[i] * (r[i] - l[i] - 1));
        return ans;
    }
};

2866. 美丽塔 II - 力扣（LeetCode）

class Solution {
public:
    long long maximumSumOfHeights(vector<int>& nums) {
        int n = nums.size();
        long long sum = 0, ans = 0;

        vector<long long> pre(n, 0), suf(n, 0);// 记录前缀和和后缀和
        stack<int> stk;
        stk.push(-1);// 哨兵
        for (int i = 0; i < n; ++i) {
            while (stk.size() > 1 && nums[i] < nums[stk.top()]) {// 维护一个单调递增的栈，注意由于哨兵，判断条件是stk.size()>1
                int r = stk.top();
                stk.pop();
                sum -= (long long)nums[r] * (r - stk.top());// 减去前面比nums[i]高的柱子
            }
            sum += (long long)nums[i] * (i - stk.top());// 加上以nums[i]为高的矩形
            pre[i] = sum;
            stk.push(i);
        }

        sum = 0;
        stk = stack<int>();
        stk.push(n);// 哨兵
        for (int i = n - 1; i >= 0; --i) {
            while (stk.size() > 1 && nums[i] < nums[stk.top()]) {
                int l = stk.top();
                stk.pop();
                sum -= (long long)nums[l] * (stk.top() - l);
            }
            sum += (long long)nums[i] * (stk.top() - i);
            suf[i] = sum;
            stk.push(i);
        }

        for (int i = 0; i < n; ++i)
            ans = max(ans, pre[i] + suf[i] - nums[i]);// nums[i]被加了两次
        return ans;
    }
};

1944. 队列中可以看到的人数 - 力扣（LeetCode）

class Solution {
public:
    vector<int> canSeePersonsCount(vector<int>& nums) {
        int n = nums.size();
        vector<int> ans(n, 0);
        stack<int> st;
        for (int i = 0; i < n; ++i) {
            while (!st.empty() && nums[i] > nums[st.top()]) {
                ++ans[st.top()];// 入栈的时候，由于高于栈顶元素，因此栈顶元素一定可以看到这个新入栈的元素
                st.pop();// 但是i之后的元素，这个栈顶元素都看不见了，pop
            }
            if (!st.empty())// 在pop掉所有小于nums[i]的元素之后，栈顶元素（如果存在的话）可以看到这个新入栈的元素
                ++ans[st.top()];
            st.push(i);
        }
        return ans;
    }
};

853. 车队 - 力扣（LeetCode）

阅读理解题。题意要求，按照每辆车离终点的距离进行排序，然后依次计算出到达终点所需时间，最后，进入一次单调递增栈（小于栈顶的元素就是与前一个车队合并了）。

class Solution {
public:
    int carFleet(int target, vector<int>& position, vector<int>& speed) {
        int n = position.size();
        vector<pair<int, int>> cars(n);
        for (int i = 0; i < n; i++)
            cars[i] = pair<int, int>(target - position[i], speed[i]);
        sort(cars.begin(), cars.end());

        vector<double> times;
        for (auto car : cars)
            times.push_back(car.first / (double)car.second);

        stack<double> stk;
        for (auto time : times)
            if (stk.empty() || stk.top() < time)
                stk.push(time);

        return stk.size();
    }
};