PDD 居然还看学校开工资，意难平。。

最新推荐文章于 2024-09-29 20:00:00 发布

宫水三叶的刷题日记

最新推荐文章于 2024-09-29 20:00:00 发布

阅读量923

点赞数 10

文章标签：后端

本文链接：https://blog.csdn.net/weixin_33243821/article/details/142552285

版权

PDD

前天发了 PDD 各岗位薪资一览表，不少同学后台私信，表示 PDD 的工资方差很大，都是同一年校招进来，同组同事一样都是 985，都是一个级别的 offer，但对方工资更高。

甚至有同学，将此行为归类为「公司看学校开工资」：

好家伙，真把自己当纯白纸了。

不然是校招还是社招，不同人即使面试的是同一岗位，同一位面试官，也会因为表现不同，得到不同的评分，而最终 HR 面中的博弈表现，更是对 offer 的最终待遇影响很大。

因此同一级别的 offer（白菜/SP/SSP）有个 1k~3k 的差异，十分正常，在哪个公司都有可能。

秋招正如火如荼，想要在复盘的时候有更多收获，在面对那些失败的经历，要善于先从自己身上找问题（面试表现 or 谈判技巧），而别一味地将原因归结到一些短时间无法改变的条件上（学历 or 学校）。

...

回归主题。

来一道和「2025 届秋招」相关的算法题。

题目描述

平台：LeetCode

题号：503

给定一个循环数组（最后一个元素的下一个元素是数组的第一个元素），输出每个元素的下一个更大元素。

数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1。

示例 1:

输入: [1,2,1]

输出: [2,-1,2]

解释: 第一个 1 的下一个更大的数是 2；
数字 2 找不到下一个更大的数； 
第二个 1 的下一个最大的数需要循环搜索，结果也是 2。

提示：

单调栈

对于「找最近一个比当前值大/小」的问题，都可以使用单调栈来解决。

单调栈就是在栈的基础上维护一个栈内元素单调。

在理解单调栈之前，我们先回想一下「朴素解法」是如何解决这个问题的。

对于每个数而言，我们需要遍历其右边的数，直到找到比自身大的数，这是一个的做法。

「之所以是，是因为每次找下一个最大值，我们是通过「主动」遍历来实现的。」

而如果使用的是单调栈的话，可以做到的复杂度，我们「将当前还没得到答案的下标暂存于栈内，从而实现「被动」更新答案。」

也就是说，栈内存放的永远是还没更新答案的下标。

具体的做法是：

每次将当前遍历到的下标存入栈内，「将当前下标存入栈内前，检查一下当前值是否能够作为栈内位置的答案（即成为栈内位置的「下一个更大的元素」），如果可以，则将栈内下标弹出。」

如此一来，我们便实现了「被动」更新答案，同时由于我们的弹栈和出栈逻辑，决定了我们「整个过程中栈内元素单调」。

还有一些编码细节，由于我们要找每一个元素的下一个更大的值，因此我们需要对原数组遍历两次，对遍历下标进行取余转换。

以及因为栈内存放的是还没更新答案的下标，可能会有位置会一直留在栈内（最大值的位置），因此我们要在处理前预设答案为 -1。而从实现那些没有下一个更大元素（不出栈）的位置的答案是 -1。

Java 代码：

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        int n = nums.length;
        int[] ans = new int[n];
        Arrays.fill(ans, -1);
        Deque<Integer> d = new ArrayDeque<>();
        for (int i = 0; i < n * 2; i++) {
            while (!d.isEmpty() && nums[i % n] > nums[d.peekLast()]) {
                int u = d.pollLast();
                ans[u] = nums[i % n];
            }
            d.addLast(i % n);
        }
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        int n = nums.size();
        vector<int> ans(n, -1);
        deque<int> d;
        for (int i = 0; i < n * 2; i++) {
            while (!d.empty() && nums[i % n] > nums[d.back()]) {
                int u = d.back();
                d.pop_back();
                ans[u] = nums[i % n];
            }
            d.push_back(i % n);
        }
        return ans;
    }
};

Python 代码：

class Solution:
    def nextGreaterElements(self, nums: List[int]) -> List[int]:
        n = len(nums)
        ans = [-1] * n
        d = deque()
        for i in range(n * 2):
            while d and nums[i % n] > nums[d[-1]]:
                u = d.pop()
                ans[u] = nums[i % n]
            d.append(i % n)
        return ans

时间复杂度：
空间复杂度：

数组模拟栈

本题不需要用到这个技巧，但是还是介绍一下，可作为拓展。

我们可以使用静态数组来模拟栈，这样我们的代码将会更快一点：

Java 代码：

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        int n = nums.length;
        int[] ans = new int[n];
        Arrays.fill(ans, -1);
        // 使用数组模拟栈，hh 代表栈底，tt 代表栈顶
        int[] d = new int[n * 2];
        int hh = 0, tt = -1;
        for (int i = 0; i < n * 2; i++) {
            while (hh <= tt && nums[i % n] > nums[d[tt]]) {
                int u = d[tt--];
                ans[u] = nums[i % n];
            }
            d[++tt] = i % n;
        }
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        int n = nums.size();
        vector<int> ans(n, -1);
        vector<int> d(n * 2);
        int hh = 0, tt = -1;
        for (int i = 0; i < n * 2; i++) {
            while (hh <= tt && nums[i % n] > nums[d[tt]]) {
                int u = d[tt--];
                ans[u] = nums[i % n];
            }
            d[++tt] = i % n;
        }
        return ans;
    }
};

Python 代码：

class Solution:
    def nextGreaterElements(self, nums: List[int]) -> List[int]:
        n = len(nums)
        ans = [-1] * n
        d = [0] * (n * 2)
        hh, tt = 0, -1
        for i in range(n * 2):
            while hh <= tt and nums[i % n] > nums[d[tt]]:
                ans[d[tt]] = nums[i % n]
                tt -= 1
            tt += 1
            d[tt] = i % n
        return ans