拼多多今年的校招薪资。。。

拼多多校招情况分析

关于校招情况分析，我们写过了争议巨巨巨巨大的华为、互联网宇宙厂字节跳动以及如今有点高攀不起的新能源车企比亚迪。

群里收集过小伙伴的意见，除上述大厂以外，大家最感兴趣的还是市值刚超过阿里的砍厂：拼多多。

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

	开发	算法	产品	运营
白菜	27k~30k	27k~32k	18k~20k	11k~12k
SP	32k~34k	34k~37k	23k~25k	13k~14k
SSP	37k~40k	38k~40k	26k~28k	15k

往年有不少岗位都还有 3W 的签字费，今年从 Offershow 的数据来看，即使是去到 SSP 的研发 base，也没有签字费。

但即使没有签字费，拼多多在招聘市场也有较大优势。

拼多多通常为 18 薪，18 薪的构成：12 个月基本工资 + 2 个月绩效 + 2 个月年终奖 + 2 个月加班费。

不愧是拼多多，招聘时就明牌了一年下来估计至少会有 2 个月加班费 🤣

但不少同学并不知道，这 2 个月的加班费，其实并不会写到 offer 里面，offer 里面只会包含「绩效 + 年终」。

于是有同学，把拼多多的年包当成 base * (14~16）去算：

如果因此去了强度和拼多多类似，但年包只有 14~15 的厂的话，这找谁说理去 🤣

...

聊完基本薪资待遇，再看看入职拼多多后的同学们的感受。

毕竟offer 只是憧憬，入职才是生活。

基本上，能明牌给你一年两个月加班费的公司，节奏上肯定是比得上华为的。

这里分享一个写得比较实在的感受贴：

工作环境一般，基本上是「网吧连坐」模式。

吃饭和午休都在工位上，事多人挤，办公室难免会有味道 ...

节奏基本上 11-11-6（周六休息，周日加班）。

三餐和种类不多的茶水间零食都是免费，打车报销。

假日少，工时长，包吃包通行，因此客观上确实会比在其他厂工作更能存钱（毕竟假期不多）。

但怎么感觉，拼多多无论是从节奏还是工作环境，都在劝退女生 🤣

最后，需要注意的是：拼多多有较强的竞业协议，离职后如果启动了竞业，那么可能未来几年都要告别大多数互联网厂。

其实关于「竞业协议」，我们也分析过前两天的字节小作文。

离职期间，通常会进入竞业协议的再确认环节，这时候需要额外小心，了解清楚，不要乱签。

若 HR 以不签就不开具离职证明/收入证明，也不要签，记得保留录音证据。

至于竞业协议启动与否，这个简单，看离职后前公司是否每个月给你打钱就知道了 🤣

...

回归主线。

既然拼多多这么香，来做一道热乎的拼多多校招算法题。

看看大家能否拿到拼多多校招的入场券。

题目描述

平台：LeetCode

题号：95

给你一个整数 n。

请你生成并返回所有由 n 个节点组成且节点值从 1 到 n 互不相同的不同二叉搜索树。

可以按「任意顺序」返回答案。

示例 1：

ini 复制代码

输入：n = 3

输出：[[1,null,2,null,3],[1,null,3,2],[2,1,3],[3,1,null,null,2],[3,2,null,1]]

示例 2：

lua 复制代码

输入：n = 1

输出：[[1]]

提示：

<math xmlns="http://www.w3.org/1998/Math/MathML"> 1 < = n < = 8 1 <= n <= 8 </math>1<=n<=8

回溯算法

题目要我们求所有所能构造的二叉搜索树的具体方案，而给定 <math xmlns="http://www.w3.org/1998/Math/MathML"> n n </math>n 个节点所能构成的二叉搜索树的个数为卡特兰数。

其他方案数同为卡特兰数的还包括：凸多边形三角划分、n 对括号正确匹配数目 ...

回到本题，根据二叉搜索搜索的特性，若某个子树的根节点为 root，那么 root 的左子树任意节点值均比 root.val 要小，root 的右子树任意节点值均比 root.val 要大。

因此，假设我们使用 <math xmlns="http://www.w3.org/1998/Math/MathML"> [ l , r ] [l, r] </math>[l,r] 连续段来构造二叉搜索树，并且选择了节点 t 作为二叉搜索树的根节点时：

那么使用 <math xmlns="http://www.w3.org/1998/Math/MathML"> [ l , t − 1 ] [l, t - 1] </math>[l,t−1] 构造出来的二叉搜索树均可作为根节点 <math xmlns="http://www.w3.org/1998/Math/MathML"> t t </math>t 的左子树
使用 <math xmlns="http://www.w3.org/1998/Math/MathML"> [ t + 1 , r ] [t + 1, r] </math>[t+1,r] 构造出来的二叉搜索树均可作为根节点 <math xmlns="http://www.w3.org/1998/Math/MathML"> t t </math>t 的右子树

也就是说，我们可以设计递归函数 List<TreeNode> dfs(int l, int r)，含义为使用连续段 <math xmlns="http://www.w3.org/1998/Math/MathML"> [ l , r ] [l, r] </math>[l,r] 进行二叉搜索树构造，并返回相应集合。

最终答案为 dfs(1,n)，起始我们可以枚举 <math xmlns="http://www.w3.org/1998/Math/MathML"> [ 1 , n ] [1, n] </math>[1,n] 范围内的的每个数 t 作为根节点，并递归 dfs(l,t-1) 和 dfs(t+1,r) 获取左右子树的集合 left 和 right。

结合「乘法原理」，枚举任意左子树和任意右子树，即可得到 t 作为根节点的二叉搜索树方案集，枚举所有 t 后即可得到所有二叉搜索树的总集。

注意：当我们运用乘法原理，来构造以 t 为根节点的二叉搜索树时，其 left 或 right 某一边可能为空集，但此时我们仍要将非空的一边子树进行挂载。为了确保两层新循环的逻辑会被执行，对于空集我们不能使用 null 来代指，而要使用 [null] 来代指。

Java 代码：

Java 复制代码

class Solution {
    public List<TreeNode> generateTrees(int n) {
        return dfs(1, n);
    }
    List<TreeNode> dfs(int l, int r) {
        if (l > r) return new ArrayList<>(){{add(null);}};
        List<TreeNode> ans = new ArrayList<>();
        for (int i = l; i <= r; i++) {
            for (TreeNode x : dfs(l, i - 1)) {
                for (TreeNode y : dfs(i + 1, r)) {
                    TreeNode root = new TreeNode(i);
                    root.left = x; root.right = y;
                    ans.add(root);
                }
            }
        }
        return ans;
    }
}

C++ 代码：

C++ 复制代码

class Solution {
public:
    vector<TreeNode*> generateTrees(int n) {
        return dfs(1, n);
    }
    vector<TreeNode*> dfs(int l, int r) {
        if (l > r) return vector<TreeNode*>{NULL};
        vector<TreeNode*> ans;
        for (int i = l; i <= r; i++) {
            for (TreeNode* x : dfs(l, i - 1)) {
                for (TreeNode* y : dfs(i + 1, r)) {
                    // 创建当前节点并添加到结果列表中
                    TreeNode* root = new TreeNode(i);
                    root->left = x;
                    root->right = y;
                    ans.push_back(root);
                }
            }
        }
        return ans;
    }
};

Python 代码：

Python 复制代码

class Solution:
    def generateTrees(self, n: int) -> List[Optional[TreeNode]]:
        def dfs(l, r):
            if l > r:
                return [None]
            ans = []
            for i in range(l, r + 1):
                for x in dfs(l, i - 1):
                    for y in dfs(i + 1, r):
                        root = TreeNode(i)
                        root.left, root.right = x, y
                        ans.append(root)
            return ans
        return dfs(1, n)

TypeScript 代码：

TypeScript 复制代码

function generateTrees(n: number): Array<TreeNode | null> {
    function dfs(l: number, r: number): Array<TreeNode | null> {
        if (l > r) return [null]
        const ans = new Array<TreeNode>()
        for (let i = l; i <= r; i++) {
            for (const x of dfs(l, i - 1)) {
                for (const y of dfs(i + 1, r)) {
                    const root = new TreeNode(i)
                    root.left = x; root.right = y
                    ans.push(root)
                }
            }
        }
        return ans
    }
    return dfs(1, n)
}

时间复杂度：卡特兰数
空间复杂度：卡特兰数

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

欢迎关注，明天见。

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