又一家 955 外企巨头宣布裁员 9%

业务增速不佳，裁员 9%

近日，eBay 总裁兼 CEO 宣布，由于业务增速不佳，将裁减约 1000 个工作岗位，占其全职员工约 9%。

他解释道：裁员是必要的，因为 eBay 的总人数和开支已经超过我们的业务增长。

eBay 作为一家老牌从事跨境电商业务的公司，在中国也是最早进入 955 名单（早上 9 点上班，下午 5 点下班，一周 5 个工作日）的外企公司之一：

现如今裁员比例去到 9%，当中自然也包括一些中国区的岗位。

距裁员消息发布不到一天，已经有不少 eBay 的同学开始现身说法，证实了裁员包含中国区岗位这一说法：

中国区裁员的具体人数尚不清楚，有说仅为几十个，也有说涉及上百人的。

消息一出，国内各个厂的 HR 纷纷涌向这些帖子的评论区，想趁机捞一波人。

不知道他们有没有考虑这些外企小伙伴，与国内大厂节奏的匹配程度。

...

然后是吃瓜群众最关心的赔偿环节了。

虽然 eBay 裁员是因为业务增速不行，但赔偿方案可一点不含糊。

赔偿方案：n+3+一个月缓冲期，基本上可以理解成是 n+4 了。

这无论是相比前几周宣布裁员，但按 Week 进行赔偿的海外巨头，还是近期频频爆出的直接暴力裁员的国内公司，都算是十分良心的存在了。

对于遭遇 eBay 裁员的小伙伴来说，这个赔偿方案，可以说是"不幸中万幸"了。

...

回归主线。

实在没有找到 eBay 的真题。

做一道「外企算法真题」热榜中的第一名吧。

题目描述

平台：LeetCode

题号：236

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为："对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。"

示例 1：

css 复制代码

输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1

输出：3

解释：节点 5 和节点 1 的最近公共祖先是节点 3 。

示例 2：

css 复制代码

输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4

输出：5

解释：节点 5 和节点 4 的最近公共祖先是节点 5 。因为根据定义最近公共祖先节点可以为节点本身。

示例 3：

css 复制代码

输入：root = [1,2], p = 1, q = 2

输出：1

提示：

树中节点数目在范围 <math xmlns="http://www.w3.org/1998/Math/MathML"> [ 2 , 1 0 5 ] [2, 10^5] </math>[2,105] 内。
<math xmlns="http://www.w3.org/1998/Math/MathML"> − 1 0 9 < = N o d e . v a l < = 1 0 9 -10^9 <= Node.val <= 10^9 </math>−109<=Node.val<=109
所有 Node.val 互不相同。
<math xmlns="http://www.w3.org/1998/Math/MathML"> p ! = q p != q </math>p!=q
p 和 q 均存在于给定的二叉树中。

DFS

常见的 LCA 问题。

设计 DFS 函数 boolean dfs(TreeNode cur, TreeNode t, List<TreeNode> path)：

cur 为当前处理到的节点
t 为需要找到的目的节点
path 为从根节点到当前节点
cur 所经过的路径

若能够以当前节点 cur 为根的子树包含目标节点 t，函数返回 true，否则返回 false。

调用函数分别传入 p 和 q 作为目标节点，从而得到从根节点到 p 和 q 的路径列表，遍历路径找到最后一个相同的节点即是答案。

Java 代码：

Java 复制代码

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        List<TreeNode> a = new ArrayList<>(), b = new ArrayList<>();
        dfs(root, p, a); dfs(root, q, b);
        TreeNode ans = null;
        for (int i = 0; i < Math.min(a.size(), b.size()) && a.get(i) == b.get(i); i++) ans = a.get(i);
        return ans;
    }
    boolean dfs(TreeNode cur, TreeNode t, List<TreeNode> path) {
        if (cur == null) return false;
        path.add(cur);
        if (cur == t || dfs(cur.left, t, path) || dfs(cur.right, t, path)) {
            return true;
        } else {
            path.remove(path.size() - 1);
            return false;
        }
    }
}

C++ 代码：

C++ 复制代码

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        vector<TreeNode*> a, b;
        dfs(root, p, a); dfs(root, q, b);
        TreeNode* ans = nullptr;
        for (int i = 0; i < min(a.size(), b.size()) && a[i] == b[i]; i++) ans = a[i];
        return ans;
    }
    bool dfs(TreeNode* cur, TreeNode* t, vector<TreeNode*>& path) {
        if (!cur) return false;
        path.push_back(cur);
        if (cur == t || dfs(cur->left, t, path) || dfs(cur->right, t, path)) {
            return true;
        } else {
            path.pop_back();
            return false;
        }
    }
};

Python 代码：

Python 复制代码

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        def dfs(cur, t, path):
            if not cur:
                return False
            path.append(cur)
            if cur == t or dfs(cur.left, t, path) or dfs(cur.right, t, path):
                return True
            else:
                path.pop()
                return False
        a, b = [], []
        dfs(root, p, a)
        dfs(root, q, b)
        ans = None
        for i in range(min(len(a), len(b))):
            if a[i] == b[i]:
                ans = a[i]
        return ans

TypeScript 代码：

TypeScript 复制代码

function lowestCommonAncestor(root: TreeNode | null, p: TreeNode | null, q: TreeNode | null): TreeNode | null {
    const a = [], b = [];
    dfs(root, p, a);
    dfs(root, q, b);
    let ans = null;
    for (let i = 0; i < Math.min(a.length, b.length) && a[i] === b[i]; i++) ans = a[i];
    return ans;
}
function dfs(cur: TreeNode | null, t: TreeNode | null, path: TreeNode[]): boolean {
    if (!cur) return false;
    path.push(cur);
    if (cur === t || dfs(cur.left, t, path) || dfs(cur.right, t, path)) {
        return true;
    } else {
        path.pop();
        return false;
    }
}

时间复杂度： <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)

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

欢迎关注，明天见。

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