LeetCode 2454. 下一个更大元素 IV

一、题目

1、题目描述

给你一个下标从 0 开始的非负整数数组 nums 。对于 nums 中每一个整数，你必须找到对应元素的 第二大 整数。

如果 nums[j] 满足以下条件，那么我们称它为 nums[i] 的 第二大 整数：

• j > i
• nums[j] > nums[i]
• 恰好存在 一个 k 满足 i < k < j 且 nums[k] > nums[i] 。

如果不存在 nums[j] ，那么第二大整数为 -1 。

• 比方说，数组 [1, 2, 4, 3] 中，1 的第二大整数是 4 ，2 的第二大整数是 3 ，3 和 4 的第二大整数是 -1 。

请你返回一个整数数组 answer ，其中 answer[i]是 nums[i] 的第二大整数。

示例 1：

输入：nums = [2,4,0,9,6]
输出：[9,6,6,-1,-1]
解释：
下标为 0 处：2 的右边，4 是大于 2 的第一个整数，9 是第二个大于 2 的整数。
下标为 1 处：4 的右边，9 是大于 4 的第一个整数，6 是第二个大于 4 的整数。
下标为 2 处：0 的右边，9 是大于 0 的第一个整数，6 是第二个大于 0 的整数。
下标为 3 处：右边不存在大于 9 的整数，所以第二大整数为 -1 。
下标为 4 处：右边不存在大于 6 的整数，所以第二大整数为 -1 。
所以我们返回 [9,6,6,-1,-1] 。

示例 2：

输入：nums = [3,3]
输出：[-1,-1]
解释：
由于每个数右边都没有更大的数，所以我们返回 [-1,-1] 。

2、接口描述

​

class Solution {
public:
    vector<int> secondGreaterElement(vector<int>& nums) {
        
    }
};

3、原题链接

2454. 下一个更大元素 IV

---

二、解题报告

1、思路分析

从题目要求上能感觉到该题是考察对于数据结构的掌握的，算法考察并不是重点。

如果仅仅是找出第一个更大的元素，那么我们维护一个单调栈一次遍历即可。

但是如果是第二个更大元素的话，该怎么做呢？

还是基于前面，我们维护一个单调递减栈，如果枚举元素大于栈顶，那么栈中小于枚举元素的元素都找到了第一个更大元素，我们可以用一个缓冲容器将其暂时保存起来。

当我们后续枚举新元素的时候，如果新元素大于缓冲容器中的某些元素，那么这些元素的下一个更大元素就是这个新元素。

所以问题就落脚到了缓冲容器的选择。

F1 优先级队列（小根堆）

这样方便我们找到缓冲容器中以当前元素为下一个更大元素的元素

F2 单调栈

我们可以再开一个单调栈，同样维护单调递减栈不妨称为缓冲栈，我们把缓冲栈中符合条件的元素弹出之后，缓冲栈中剩下的元素都大于等于枚举元素，而对于第一个栈中要弹出的元素又都小于枚举元素，因而我们枚举时可以先处理缓冲栈再将第一个栈中弹出的元素放到缓冲栈中

2、复杂度

F1: 时间复杂度:O(n)        空间复杂度:O(nlogn)

F1: 时间复杂度:O(n)        空间复杂度:O(nl)

3、代码详解

​F1单调栈+优先级队列

class Solution {
public:
using PII = pair<int,int>;
    vector<int> secondGreaterElement(vector<int>& nums) {
        int n = nums.size();
        vector<int> ret(n,-1);
        auto cmp = [&](int x , int y){
            return nums[x] > nums[y];
        };
        priority_queue<int , vector<int> , decltype(cmp)> pq{cmp};
        stack<int> s;
        for(int i = 0 ; i < n ; i++)
        {
            while(!pq.empty() && nums[i] > nums[pq.top()])
            {
                ret[pq.top()] = nums[i];pq.pop();
            }
            while(!s.empty() && nums[i] > nums[s.top()])
            {
                pq.emplace(s.top());s.pop();
            }
            s.emplace(i);
        }

        return ret;
    }
};

F2 双单调栈

class Solution {
public:
    vector<int> secondGreaterElement(vector<int>& nums) {
        int n = nums.size();
        vector<int> ret(n , -1);
        vector<int> s , cache;

        for(int i = 0 ; i < n ; i++)
        {
            while(!cache.empty() && nums[i] > nums[cache.back()])
            {
                ret[cache.back()] = nums[i] , cache.pop_back();
            }
            int t = s.size();
            while(t && nums[i] > nums[s[t - 1]])
               t--;
            cache.insert(cache.end() , s.begin() + t , s.end());
            s.resize(t);
            s.emplace_back(i);
        }

        return ret;
    }
};