美团今年的校招薪资。。。

发表于

美团校招情况分析

老规矩了，校招薪资分析和建议，这次轮到美团。

先来看看和公众号读者相关性较高的岗位对应的校招待遇：

开发 算法 产品 运营
白菜 18k~21k 21k~24k 18k~19k 10k~14k
SP 22k~27k 25k~30k 20k~22k 15k~16k
SSP 28k~32k 31k~46k 23k~25k 17k~18k

以上所有岗位 \ 15.5 即为年包收入。*

部分岗位（例如算法的 SP 及以上）还会有签字费（一般为 555W）和股票（不定，最高去到 70w70w70w，分四年归属）。

虽然「大厂校招薪资」系列文章我们已经写到了第 555 篇了，但还是有同学会对一些概念比较模糊。

这一定程度上也反映了确实不少首次参与校招的同学会关注这个系列。

既然这个系列本就以帮助他们为初衷，那么有义务连带着对一些概念进行解释。

  • base：每月的税前底薪；
  • 签字费：你可以理解成新员工的红包奖金，只有部分面试阶段特别优秀的人选或重要岗位会有。会在入职的时候的直接发放，只发放一次；
  • 年终奖/绩效奖：通常我们会用「base * X个月」来计算年包中的现金部分，那么 X 中大于 121212 个月的部分，就是年终奖。

年终奖没有一个统一的标准，有些好的公司会写到劳动合同上，有些则不写，甚至还有连 offer 上都不写年终奖细则的公司，仅在与 HR 的交流中进行口头承诺；

年终奖和签字费不同，是后面的年份都按这个标准执行，并非只承诺入职第一年的哈。除非晋升或者内部调岗，才有可能会重新调整（这个有不少同学搞混这个）。

  • 期权股票：这是年包中的非现金部分，也不是所有入职员工都会有的，除非公司全员持股。

一般来说，不同的公司，会根据是否已上市，有不同的发放规则。

对于新人入职，关于期权股票发放，最为常见的是，承诺给你 xxxx 期权/股票，分 xxxx 年归属/到账（一般是 333~555 年），然后可能季度或者年度，还会再给一些期权/股票。

只有归属/到账后，你才能按比例参与赎回/交易，转成现金。

这部分可能还是有点抽象，举个实际的 🌰 吧：

例如入职时承诺给 100010001000 股，等额按 444 年归属，归属后需等待 111 年才能换现金。

那么最快的第一笔，需要在入职第 222 年年末才能换现金（第 111 年归属、第 222 年等待）；最慢的第四笔，需要在入职第 555 年年末才能换现金（第 444 年归属、第 555 年等待）。

也就是说，入职送的这 100010001000 股，实际上你需要很多年后才能彻底换现金。中间的价格波动，也会反映成你的升值 or 贬值。

好，交代完这些基本概念之后，你大概率明白美团的年包大概去到什么水平了。

…

看完校招薪资待遇，传统习惯，我们还会从读者或者网上，收集一些在该厂工作的真实体验分享给大家。

这次分享给大家的是来自牛客网的一篇热乎实习贴：

还就是那个“开水团”：暗指除了开水免费喝，没有其他福利。

但公司氛围还是不错的，各位同学可结合自身条件进行综合比较。

…

回归主线。

想拿美团的校招 offer，需要掌握好算法，尤其是需要掌握「链表」类的算法题。

在 LeetCode 上的美团真题榜中，排名前三的，有两道是链表类题目。

我们今天先来做排名前三中通过率最低的一道。

题目描述

平台：LeetCode

题号：82

存在一个按升序排列的链表，给你这个链表的头节点 head，请你删除链表中所有存在数字重复情况的节点，只保留原始链表中没有重复出现的数字。

返回同样按升序排列的结果链表。

示例 1：

1
2
3
ini复制代码输入：head = [1,2,3,3,4,4,5]

输出：[1,2,5]

示例 2：

1
2
3
ini复制代码输入：head = [1,1,1,2,3]

输出：[2,3]

提示：

  • 链表中节点数目在范围 [0,300][0, 300][0,300] 内
  • −100<=Node.val<=100-100 <= Node.val <= 100−100<=Node.val<=100
  • 题目数据保证链表已经按升序排列

基本思路

几乎所有的链表题目，都具有相似的解题思路。

  1. 建一个虚拟头节点 dummy 以减少边界判断，往后的答案链表会接在 dummy 后面
  2. 使用 tail 代表当前有效链表的结尾
  3. 通过原输入的 head 指针进行链表扫描

我们会确保「进入外层循环时 head 不会与上一节点相同」，因此插入时机：

  1. head 已经没有下一个节点，head 可以被插入
  2. head 有一下个节点，但是值与 head 不相同，head 可以被插入

Java 代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Java复制代码class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        ListNode dummy = new ListNode();
        ListNode tail = dummy;
        while (head != null) {
            // 进入循环时，确保了 head 不会与上一节点相同
            if (head.next == null || head.val != head.next.val) {
                tail.next = head;
                tail = head;
            }
            // 如果 head 与下一节点相同，跳过相同节点
            while (head.next != null && head.val == head.next.val) head = head.next;
            head = head.next;
        }
        tail.next = null;
        return dummy.next;
    }
}

C++ 代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
C++复制代码class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        ListNode* dummy = new ListNode();
        ListNode* tail = dummy;
        while (head != nullptr) {
            // 进入循环时，确保了 head 不会与上一节点相同
            if (head->next == nullptr || head->val != head->next->val) {
                tail->next = head;
                tail = head;
            }
            // 如果 head 与下一节点相同，跳过相同节点
            while (head->next != nullptr && head->val == head->next->val) head = head->next;
            head = head->next;
        }
        tail->next = nullptr;
        return dummy->next;
    }
};

Python 代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Python复制代码class Solution:
    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
        dummy = ListNode()
        tail = dummy
        while head:
            # 进入循环时，确保了 head 不会与上一节点相同
            if not head.next or head.val != head.next.val:
                tail.next = head
                tail = head
            # 如果 head 与下一节点相同，跳过相同节点
            while head.next and head.val == head.next.val: head = head.next
            head = head.next
        tail.next = None
        return dummy.next

TypeScript 代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
TypeScript复制代码function deleteDuplicates(head: ListNode | null): ListNode | null {
    const dummy: ListNode = new ListNode();
    let tail: ListNode | null = dummy;
    while (head) {
        // 进入循环时，确保了 head 不会与上一节点相同
        if (!head.next || head.val !== head.next.val) {
            tail.next = head;
            tail = head;
        }
        // 如果 head 与下一节点相同，跳过相同节点
        while (head.next && head.val === head.next.val) head = head.next;
        head = head.next;
    }
    tail.next = null;
    return dummy.next;
};
  • 时间复杂度：O(n)O(n)O(n)
  • 空间复杂度：O(1)O(1)O(1)

拓展

如果问题变为「相同节点保留一个」，该如何实现？

还是类似的解题思路。

  1. 建一个虚拟头节点 dummy 以减少边界判断，往后的答案链表会接在 dummy 后面
  2. 使用 tail 代表当前有效链表的结尾
  3. 通过原输入的 head 指针进行链表扫描

Java 代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Java复制代码class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if (head == null) return head;
        ListNode dummy = new ListNode(-109);
        ListNode tail = dummy;
        while (head != null) {
            // 值不相等才追加，确保了相同的节点只有第一个会被添加到答案
            if (tail.val != head.val) {
                tail.next = head;
                tail = tail.next;
            }
            head = head.next;
        }
        tail.next = null;
        return dummy.next;
    }   
}

C++ 代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
C++复制代码class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if (!head) return head;
        ListNode* dummy = new ListNode(-109);
        ListNode* tail = dummy;
        while (head) {
            // 值不相等才追加，确保了相同的节点只有第一个会被添加到答案
            if (tail->val != head->val) {
                tail->next = head;
                tail = tail->next;
            }
            head = head->next;
        }
        tail->next = nullptr;
        return dummy->next;
    }
};

Python 代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
Python复制代码class Solution:
    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head: return head
        dummy = ListNode(-109)
        tail = dummy
        while head:
            # 值不相等才追加，确保了相同的节点只有第一个会被添加到答案
            if tail.val != head.val:
                tail.next = head
                tail = tail.next
            head = head.next
        tail.next = None
        return dummy.next

TypeScript 代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
TypeScript复制代码function deleteDuplicates(head: ListNode | null): ListNode | null {
    if (!head) return head;
    const dummy: ListNode = new ListNode(-109);
    let tail: ListNode | null = dummy;
    while (head) {
        // 值不相等才追加，确保了相同的节点只有第一个会被添加到答案
        if (tail.val !== head.val) {
            tail.next = head;
            tail = tail.next;
        }
        head = head.next;
    }
    tail.next = null;
    return dummy.next;
};
  • 时间复杂度：O(n)O(n)O(n)
  • 空间复杂度：O(1)O(1)O(1)

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

欢迎关注，明天见。

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

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%