苏州佳能，赔偿 N+12 or 2N+12，感动常在？

苏州佳能

昨晚，有网友爆料「苏州佳能」开始新一批裁员，规模涉及上千人，赔偿刷新了外企裁员的天花板。

不看具体方案的话，内心不会有太多波澜。

毕竟国内肯按规定赔偿的公司不多，而给出超额赔偿的基本都是外企。

外企隔段时间就搞"恶意赔偿"，让网友体验"裁员等同拆迁"的感觉，也不是什么新鲜事了。

但一看赔偿方案：无固定合同期限赔偿 N+12 or 2N+12。

好家伙。

原以为我已对外企裁员赔偿麻木，实际上我只是对外企赔偿 N+4、N+6 等麻木罢了 🤣🤣

但就在今天中午，佳能的官网接线员回应称：赔偿 N+12 or 2N+12 的消息是假的。公司不是在裁员是再就业，再就业是可以自己选的，达到标准有赔款，但赔偿标准不清楚。

不是裁员，但有赔款这一事，而赔偿标准是多少，没有具体回应。

其实每隔一段时间，就会有赔偿 N+12 的假新闻出现，除了清一色都是 N+12 这一数字以外，还清一色的都在苏州 🤣🤣

此前的新闻更离谱，有说外企赔偿 N+12+一年社保，也有说赔偿 N+12+股票的，这些后来都被辟谣了。

这些新闻看多了，都感觉公司不是因为缺钱而裁员，而是因为有钱而裁员。

至于为什么此类新闻总是出现在苏州，也好理解，毕竟苏州是一座外企居多的城市，生活节奏相比上海要慢一些，自然造就了"神仙外企到处是，打工人天堂"的印象。

...

回归主题。

来一道和「字节跳动」相关的题目（字节的瓜，明天说）。

题目描述

平台：LeetCode

题号：2477

给你一棵 n 个节点的树（一个无向、连通、无环图），每个节点表示一个城市，编号从 0 到 n-1，且恰好有 n-1 条路。0 是首都。

给你一个二维整数数组 roads，其中，表示城市 a 和 b 之间有一条双向路。

每个城市里有一个代表，他们都要去首都参加一个会议。

每座城市里有一辆车，给你一个整数 seats 表示每辆车里面座位的数目。

城市里的代表可以选择乘坐所在城市的车，或者乘坐其他城市的车。相邻城市之间一辆车的油耗是一升汽油。

请你返回到达首都最少需要多少升汽油。

示例 1：

输入：roads = [[0,1],[0,2],[0,3]], seats = 5

输出：3

解释：
- 代表 1 直接到达首都，消耗 1 升汽油。
- 代表 2 直接到达首都，消耗 1 升汽油。
- 代表 3 直接到达首都，消耗 1 升汽油。
最少消耗 3 升汽油。

示例 2：

输入：roads = [[3,1],[3,2],[1,0],[0,4],[0,5],[4,6]], seats = 2

输出：7

解释：
- 代表 2 到达城市 3 ，消耗 1 升汽油。
- 代表 2 和代表 3 一起到达城市 1 ，消耗 1 升汽油。
- 代表 2 和代表 3 一起到达首都，消耗 1 升汽油。
- 代表 1 直接到达首都，消耗 1 升汽油。
- 代表 5 直接到达首都，消耗 1 升汽油。
- 代表 6 到达城市 4 ，消耗 1 升汽油。
- 代表 4 和代表 6 一起到达首都，消耗 1 升汽油。
最少消耗 7 升汽油。

示例 3：

输入：roads = [], seats = 1

输出：0

解释：没有代表需要从别的城市到达首都。

提示：

roads 表示一棵合法的树。

DFS

将双向图看作是以节点 0 为根的有向树，从每个节点出发往 0 前行，可看作是自底向上的移动过程。

当 seats = 1 时，每个节点前往 0 的过程相互独立，总油耗为每节点到 0 的最短距离之和。

当 seats 不为 1 时，考虑组成顺风车，此时总的油耗不该超过 seats = 1 的情况。

不难发现，「只有「深度大的节点，在前往 0 过程中，搭乘深度小顺风车」可减少油耗」（例如在上图节点 3 在经过节点 1 时搭乘顺风车，可与节点 1 合计使用一份油耗前往到 0），否则如果是深度小的节点先往深度大的节点走，再一同前往 0，会额外多经过某些边，产生不必要的油耗。

考虑组成顺风车时，总油耗该如何计算。

基于上述分析，无论 seats 是否为 1（是否组成顺风车），每个节点前往 0 的路径总是不变，即经过的边固定不变，必然是自底向上。

因此我们可统计每条边会被多少个节点经过，通过 DFS 统计「以每个节点为根时，子树的节点数量」即是经过该节点往上的边。

知道经过某条边的节点数量 cnt 后，ceil(cnt/seats) 即是该边对答案的贡献。

Java 代码：

class Solution {
    int N = 100010, M = 2 * N, idx = 0;
    int[] he = new int[N], e = new int[M], ne = new int[M];
    void add(int a, int b) {
        e[idx] = b;
        ne[idx] = he[a];
        he[a] = idx++;
    }
    long ans = 0;
    public long minimumFuelCost(int[][] roads, int seats) {
        int n = roads.length + 1;
        Arrays.fill(he, -1);
        for (int[] r : roads) {
            int a = r[0], b = r[1];
            add(a, b); add(b, a);
        }
        dfs(0, -1, seats);
        return ans;
    }
    int dfs(int u, int fa, int t) {
        int cnt = 1;
        for (int i = he[u]; i != -1; i = ne[i]) {
            int j = e[i];
            if (j == fa) continue;
            cnt += dfs(j, u, t);
        }
        if (u != 0) ans += Math.ceil(cnt * 1.0 / t);
        return cnt;
    }
}

C++ 代码：

class Solution {
public:
    int N = 100010, M = 2 * N, idx = 0;
    int he[100010], e[200020], ne[200020];
    long long ans = 0;
    void add(int a, int b) {
        e[idx] = b;
        ne[idx] = he[a];
        he[a] = idx++;
    }
    long long minimumFuelCost(vector<vector<int>>& roads, int seats) {
        int n = roads.size() + 1;
        memset(he, -1, sizeof(he));
        for (auto& r : roads) {
            int a = r[0], b = r[1];
            add(a, b); add(b, a);
        }
        dfs(0, -1, seats);
        return ans;
    }
    int dfs(int u, int fa, int t) {
        int cnt = 1;
        for (int i = he[u]; i != -1; i = ne[i]) {
            int j = e[i];
            if (j == fa) continue;
            cnt += dfs(j, u, t);
        }
        if (u != 0) ans += ceil(cnt * 1.0 / t);
        return cnt;
    }
};

Python 代码：

class Solution:
    def minimumFuelCost(self, roads: List[List[int]], seats: int) -> int:
        n, m, ans = len(roads) + 1, len(roads) * 2 + 1, 0
        he, e, ne, idx = [-1] * n, [0] * m, [0] * m, 0

        def add(a, b):
            nonlocal idx
            e[idx] = b
            ne[idx] = he[a]
            he[a] = idx
            idx += 1

        def dfs(u, fa, t):
            nonlocal ans
            cnt = 1
            i = he[u]
            while i != -1:
                j, i = e[i], ne[i]
                if j == fa: continue
                cnt += dfs(j, u, t)
            if u != 0:
                ans += math.ceil(cnt * 1.0 / t)
            return cnt

        for a, b in roads:
            add(a, b)
            add(b, a)
        dfs(0, -1, seats)
        return ans

TypeScript 代码：

function minimumFuelCost(roads: number[][], seats: number): number {
    const n = roads.length + 1, m = n * 2;
    const he = Array(n).fill(-1), e = Array(m).fill(0), ne = Array(m).fill(0);
    let ans = 0, idx = 0;
    const add = function(a: number, b: number) {
        e[idx] = b;
        ne[idx] = he[a];
        he[a] = idx++;
    }
    const dfs = function(u: number, fa: number, t: number): number {
        let cnt = 1;
        for (let i = he[u]; i != -1; i = ne[i]) {
            const j = e[i];
            if (j == fa) continue;
            cnt += dfs(j, u, t);
        }
        if (u != 0) ans += Math.ceil(cnt * 1.0 / t);
        return cnt;
    }
    for (const [a, b] of roads) {
        add(a, b); add(b, a);
    }
    dfs(0, -1, seats);
    return ans;
};