京东又要加薪了，将要加到20薪。。。-优快云博客

本文链接：https://blog.youkuaiyun.com/abcdef314159/article/details/142385664

精品推荐：

《征服数据结构》专栏：50多种数据结构彻底征服

《经典图论算法》专栏：50多种经典图论算法全部掌握

昨天(9月13号)京东集团宣布再次启动加薪：自2024年10月1日起，京东零售集团和职能体系将用两年时间实现20薪，其他部门也将随后陆续启动加薪计划。

在这种大环境下，不少企业选择开源(猿)节流，降本增效(笑)，而京东却反其道而行之，给员工加薪，也是难能可贵。目前很多企业连15薪都达不到，京东能加到20薪，在整个中国也是凤毛麟角，屈指可数。

网友评论：

--------------下面是今天的算法题--------------

来看下今天的算法题，这题是LeetCode的第2454题：下一个更大元素 IV。

问题描述

来源：LeetCode第2454题

难度：困难

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

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

1，j > i

2，nums[j] > nums[i]

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

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

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] 。

1 <= nums.length <= 10^5
0 <= nums[i] <= 10^9

问题分析

关于下一个更大元素，在LeetCode上总共有4道，前面我们已经讲了3道，今天这个是最后一道，关于前面讲的可以看下：

下一个更大元素 I

下一个更大元素 II

下一个更大元素 III

这题说的是找出当前元素后面第 2 大的整数，这里我们可以使用单调栈加上堆两种数据结构来解决。

如果当前元素比前面某个元素num大，就把num添加到堆中，这样我们就可以保证堆中的的元素都已经遇到了后面比它大的值。

如果堆中的元素 x 小于当前遍历的元素，说明 x 遇到了右边第 2 个比它大的，我们以示例 1 为例画个图看下。

JAVA：

public int[] secondGreaterElement(int[] nums) {
    int[] ans = new int[nums.length];
    Arrays.fill(ans, -1);
    Stack<Integer> stk = new Stack<>();
    PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
    for (int i = 0; i < nums.length; ++i) {
        // 堆中的元素都小于某一个值，如果再小于nums[i]，说明nums[i]就是第二大的值。
        while (!pq.isEmpty() && pq.peek()[0] < nums[i])
            ans[pq.poll()[1]] = nums[i];
        // 栈顶元素小于当前元素nums[i]的都添加到堆中
        while (!stk.isEmpty() && nums[stk.peek()] < nums[i])
            pq.offer(new int[]{nums[stk.peek()], stk.pop()});
        stk.push(i);
    }
    return ans;
}

C++：

public:
    vector<int> secondGreaterElement(vector<int> &nums) {
        vector<int> ans(nums.size(), -1);
        stack<int> stk;
        // 使用lambda表达式定义比较函数，这里我们使用pair<int, int>来存储值和索引
        auto comp = [](const pair<int, int> &a, const pair<int, int> &b) {
            return a.first > b.first;
        };
        priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(comp)> pq(comp);
        for (int i = 0; i < nums.size(); ++i) {
            // 移除堆中所有小于当前nums[i]的元素，并更新答案
            while (!pq.empty() && pq.top().first < nums[i]) {
                ans[pq.top().second] = nums[i];
                pq.pop();
            }
            // 将栈中所有小于当前nums[i]的元素弹出，并将它们的索引和值作为pair加入堆中
            while (!stk.empty() && nums[stk.top()] < nums[i]) {
                pq.emplace(nums[stk.top()], stk.top());
                stk.pop();
            }
            // 将当前索引压入栈中
            stk.push(i);
        }
        return ans;
    }

Python：

def secondGreaterElement(self, nums: List[int]) -> List[int]:
    ans = [-1] * len(nums)
    stk = []
    pq = []
    for i, num in enumerate(nums):
        while pq and pq[0][0] < num:
            _, index = heapq.heappop(pq)
            ans[index] = num
        while stk and nums[stk[-1]] < num:
            heapq.heappush(pq, (nums[stk[-1]], stk.pop()))
        stk.append(i)
    return ans