代码随想录算法训练营第六十二天_第十章_单调栈 | 739. 每日温度、496.下一个更大元素Ⅰ

LeetCode 739. 每日温度

        给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指对于第 i 天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用 0 来代替。

temperatures [73, 74, 75, 71, 69, 72, 76, 73]

         answer [1, 1, 4, 2, 1, 1, 0, 0]

👉找元素右边第一个比自己大的元素
文章讲解https://programmercarl.com/0739.%E6%AF%8F%E6%97%A5%E6%B8%A9%E5%BA%A6.html

⭐什么时候用单调栈？

        通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，此时我们就要想到可以用单调栈了。

• 思路：
  • 暴力解法：时间复杂度O(n^2)
  • 单调栈解法：时间复杂度O(n)    空间复杂度：O(n)    空间换时间
    • 考虑：
      1. 单调栈里存放什么？下标（因为计算距离、存入结果集时需要下标）
      2. 单调栈里元素是递增还是递减？从栈顶到栈底递增
    • 使用单调栈：​​​​​​​
      1. 当前遍历的元素T[i]小于栈顶元素T[st.top()]的情况👉入栈
      2. 当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况👉入栈
      3. 当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况👉计算距离 + 出栈
• 代码：

// 版本一
class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& T) {
        // 递增栈
        stack<int> st;
        vector<int> result(T.size(), 0);
        st.push(0);
        for (int i = 1; i < T.size(); i++) {
            if (T[i] < T[st.top()]) {                       // 情况一
                st.push(i);
            } else if (T[i] == T[st.top()]) {               // 情况二
                st.push(i);
            } else {
                while (!st.empty() && T[i] > T[st.top()]) { // 情况三
                    result[st.top()] = i - st.top();
                    st.pop();
                }
                st.push(i);
            }
        }
        return result;
    }
};

// 版本二
class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& T) {
        stack<int> st; // 递增栈
        vector<int> result(T.size(), 0);
        for (int i = 0; i < T.size(); ++i) {
            while (!st.empty() && T[i] > T[st.top()]) { // 注意栈不能为空
                result[st.top()] = i - st.top();
                st.pop();
            }
            st.push(i);

        }
        return result;
    }
};

LeetCode 496.下一个更大元素Ⅰ

        给你两个 没有重复元素 的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。

请你找出 nums1 中每个元素在 nums2 中的下一个比其大的值。

        nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出 -1 。

视频讲解文章讲解https://programmercarl.com/0496.%E4%B8%8B%E4%B8%80%E4%B8%AA%E6%9B%B4%E5%A4%A7%E5%85%83%E7%B4%A0I.html

• 思路：
  • 暴力解法：
  • 单调栈解法：
    • 没有重复元素👉可用map做映射：key为nums1[i]，value为i
    • 扫描nums2，单调栈👉nums2[i]右边比它大的第一个元素
      1. 单调栈里存放什么？下标（本题存放nums2元素值也可以，反正结果集下标需要通过map查找）
      2. 单调栈里元素是递增还是递减？从栈顶到栈底递增
    • 如果nums2[i]在nums1中出现过，将nums2[i]右边比它大的第一个元素记入结果
• 代码：

// 暴力解法：
class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        vector<int> answer(nums1.size(), -1);
        for (int i = 0; i < nums1.size(); ++i) {
            for (int j = nums2.size() - 1; nums2[j] != nums1[i]; --j) {
                if (nums2[j] > nums1[i]) {
                    answer[i] = nums2[j];
                }
            }
        }
        return answer;
    }
};

// 单调栈解法：
class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        stack<int> st;
        vector<int> result(nums1.size(), -1);
        if (nums1.size() == 0) return result;

        unordered_map<int, int> umap; // key:下标元素，value：下标
        for (int i = 0; i < nums1.size(); i++) {
            umap[nums1[i]] = i;
        }
        st.push(0);
        for (int i = 1; i < nums2.size(); i++) {
            while (!st.empty() && nums2[i] > nums2[st.top()]) {
                if (umap.count(nums2[st.top()]) > 0) { // 看map里是否存在这个元素
                    int index = umap[nums2[st.top()]]; // 根据map找到nums2[st.top()] 在 nums1中的下标
                    result[index] = nums2[i];
                }
                st.pop();
            }
            st.push(i);
        }
        return result;
    }
};

注：本题样例数据不大，暴力解法不会超时，用单调栈会绕一点；

要搞清楚，是针对nums2数组找nums2[i]右边比它大的第一个元素值👉针对nums2使用单调栈；

只不过存入结果数组时，要按nums1的位置来存，需要map来记录nums1的元素值和下标的关系！