华为今年的校招薪资。。。

华为薪资情况更新与分析

这是一篇临时加更的文章，主要对小伙伴的纠结进行一些答疑。

至于原定今天要谈的，阿里和京东那小小的十个亿，也只能稍稍往后了。

节前我们分享了最新的华为校招开奖情况，当时时间是 2023/12/23，冬至前后。

当时给出的薪资岗位统计数据，来源于牛客网在小红书上的分享。

我这里调选一些和咱们小伙伴相关性高的岗位，再简单提一下，

AI 工程师 - 32k * (14-16) - 年包约 48W（不算加班费）- 211硕士 - 上海
软件开发 - 25k * (14-16) - 年包约 36W（不算加班费）- 985硕士 - 上海
大模型研究员 - 年包 30W（不算加班费）- 211硕士 - 武汉
OD - 12k - 年包 14.4W（不算加班费）- 985本 - 深圳

在此基础上，增加 1-2k 的城市浮动：

如果参考资料 base 是上海，那么折算到非一线城市要往下减 2k；

如果参考资料 base 是东莞，那么折算到一线城市可以往上加 2k。

另外，这里特殊强调了一下，这是不算加班费统计出来的年包收入。

因为上次将开奖情况发出之后，不少华为的小伙伴现身说法：加班有加班费（OD 也有），但加班是长期的，且强制的。

因此拉长到一年来看，这部分收入对总收入影响是较大的。

在这种节奏氛围下，offer 的抉择是需要结合自身的承受能力来判定的。

对于「毕业不久」或是「经济环境想要通过就业来提升一个阶级」的小伙伴，有付出就有回报，且时薪不算低的华为，确实可以作为排名前几的候选方案。

但需要清晰认识到：这种愿意给时间就给你换钱的企业，既然有这种规则，那么交换的权利自然并不在员工手上，进入了这样的环境，意味着你需要长期用 <math xmlns="http://www.w3.org/1998/Math/MathML"> 5 × 8 5 \times 8 </math>5×8 以外的时间去换钱。这可不是一次两次的事情，是一个长期关系。

这里可能会有涉世未深的同学发问：为啥华为要这么搞，反正都要给加班费，为什么要把人的工作量拉满，用加班的钱多请一个人不行吗？

这是一个很有意思的问题。

具体的数据没有，但用简单的「劳动市场规则」和「经济原则」认知就可以分析出答案。

公司的用人成本除了可划分的工资以外，还有另外一部分成本是无法划分，跟人头绑定的，以及人数增加带来的其他隐形成本。

我们可以先忽略其他隐形成本，既然华为决定决定给加班费而不是多请一个人，必然是"基本满足"如下不等式：
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"> A 人头成本 + A 工资 ≤ B 人头成本 + B 工资 + C 人头成本 + C 工资 A人头成本 + A工资 \leq B人头成本 + B工资 + C人头成本 + C工资 </math>A人头成本+A工资≤B人头成本+B工资+C人头成本+C工资

因此华为才不会把 A 的活拆成两份，去请成 B 和 C 两个人。

更残忍的现实是，哪怕有一天上述公式的关系发生翻转，华为也大概率不会转向节奏。

因为，在质量保证的情况下，一个活由两个人共同完成相比于由一个人独自完成，沟通成本和维护依赖链，都会成倍增加。

更何况，控制人数接近于"刚好"的范围，可以最大化提高岗位薪资，这对于「降低老员工流失率」以及「提高对新员工的吸引力」都有正面作用。

在进一步的对外企业形象上，也会因为这样的节奏氛围被贴上，至少在资本看来是正面的"狼性"标签。

因此，上述其实只是一个伪等式，上面只是给大家一个大概印象，我写的也只是"基本满足"。

如果华为现在转型为养老厂，将会有大量好处被变为成本负债，出现在等式右边，最终成为否决转型为养老厂的经济理由。

综上，其实华为作为一家成熟企业，而且可能是全中国对外承受压力最大的企业，选择把弦拉满绷紧，其实并不难理解。

对我们普通人而言来说，在钟意华为薪资待遇的同时而又埋怨节奏氛围，是没有意义的。

因为是有了会扎人的蜜蜂，才有的蜜糖。

我们只要理解清楚这种劳务关系，搞清楚自己能否接受这样的长期关系，就可以了。

......

一转眼，又到了我们的主线任务，看到一道和「华为」相关的题目。

除了华为，近期还在「字节算法岗」一面要求手撕。

题目描述

平台：LeetCode

题号：739

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

示例 1:

ini 复制代码

输入: temperatures = [73,74,75,71,69,72,76,73]

输出: [1,1,4,2,1,1,0,0]

示例 2:

ini 复制代码

输入: temperatures = [30,40,50,60]

输出: [1,1,1,0]

提示：

<math xmlns="http://www.w3.org/1998/Math/MathML"> 1 < = t e m p e r a t u r e s . l e n g t h < = 1 0 5 1 <= temperatures.length <= 10^5 </math>1<= temperatures.length<=105
<math xmlns="http://www.w3.org/1998/Math/MathML"> 30 < = t e m p e r a t u r e s [ i ] < = 100 30 <= temperatures[i] <= 100 </math>30<= temperatures[i] <=100

单调栈

抽象题意为 : 求解给定序列中每个位置（右边）最近一个比其大的位置，可使用「单调栈」来进行求解。

具体的，我们可以从前往后处理所有的 <math xmlns="http://www.w3.org/1998/Math/MathML"> t e m p e r a t u r e s [ i ] temperatures[i] </math>temperatures[i]，使用某类容器装载我们所有的「待更新」的位置（下标），假设当前处理到的是 <math xmlns="http://www.w3.org/1998/Math/MathML"> t e m p e r a t u r e s [ i ] temperatures[i] </math>temperatures[i]：

若其比容器内的任意位置（下标）对应温度要低，其必然不能更新任何位置（下标），将其也加入容器尾部（此时我们发现，若有一个新的位置（下标）加入容器，其必然是当前所有待更新位置（下标）中的温度最低的，即容器内的温度单调递减）；
若其价格高于容器内的任一位置（下标）对应温度，其能够更新容器位置（下标）的答案，并且由于我们容器满足单调递减特性，我们必然能够从尾部开始取出待更新位置来进行更新答案，直到处理完成或遇到第一个无法更新位置。

由于我们需要往尾部添加和取出元素，因此容器可使用「栈」。

Java 代码：

Java 复制代码

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        int n = temperatures.length;
        int[] ans = new int[n];
        Deque<Integer> d = new ArrayDeque<>();
        for (int i = 0; i < n; i++) {
            while (!d.isEmpty() && temperatures[d.peekLast()] < temperatures[i]) {
                int idx = d.pollLast();
                ans[idx] = i - idx;
            }
            d.addLast(i);
        }
        return ans;
    }
}

C++ 代码：

C++ 复制代码

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        int n = temperatures.size();
        vector<int> ans(n);
        deque<int> d;
        for (int i = 0; i < n; i++) {
            while (!d.empty() && temperatures[d.back()] < temperatures[i]) {
                int idx = d.back();
                ans[idx] = i - idx;
                d.pop_back();
            }
            d.push_back(i);
        }
        return ans;
    }
};

Python3 代码：

Python 复制代码

class Solution:
    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
        n, he, ta = len(temperatures), 0, 0
        ans, stk = [0] * n, [-1] * n
        for i in range(n):
            while he < ta and temperatures[stk[ta - 1]] < temperatures[i]:
                ta -= 1
                idx = stk[ta]
                ans[idx] = i - idx
            stk[ta] = i
            ta += 1
        return ans

TypeScript 代码：

TypeScript 复制代码

function dailyTemperatures(temperatures: number[]): number[] {
    const n = temperatures.length
    const ans = new Array<number>(n).fill(0)
    const stk = new Array<number>(n).fill(-1)
    let he = 0, ta = 0
    for (let i = 0; i < n; i++) {
        while (he < ta && temperatures[stk[ta - 1]] < temperatures[i]) {
            const idx = stk[--ta]
            ans[idx] = i - idx
        }
        stk[ta++] = i
    }
    return ans
};

时间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n ) O(n) </math>O(n)
空间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n ) O(n) </math>O(n)

我是宫水三叶，每天都会分享算法题解，并和大家聊聊近期的所见所闻。

欢迎关注，明天见。

更多更全更热门的「笔试/面试」相关资料可访问排版精美的合集新基地 🎉🎉