砍一刀：你鄙视完了，我还是中概之星

中概之星

最近国内不少互联网公司发财报了。

挑几家有亮点的说一下。

字节跳动 2023 年实现收入 1200 亿美元（8635 亿元人民币），同比增长 40%。

增长成因主要来自 TikTok 在海外的大杀特杀。

然后是昨晚刚发财报的企鹅。

腾讯 2023 年实现收入 6090 亿人民币，同比增长 10%。

经营盈利为 1600 亿人民币，同比增长 44%，但年度盈利却只有 1180 亿人民币，同比下降 37%。

显然是腾讯财团方面投资拉了后腿，2023 年，强如腾讯，也要亏钱。

看到这里，其实大多都是利空。

企鹅财报真正的亮点是：2024 年的回购规模计划从 490 亿增加到至 1000 亿以上。

这就很有意思了。

2023 年企鹅全年总盈利也就 1180 亿人民币，这个回购力度相当于把 2023 年度利润全花在回购上。

企鹅在香港上市，港股回购后是必然要注销的。

因此这个回购计划可以说十分炸裂，不是 A 股那些只拿几个小目标来回购，回购通常还用作员工（高管）激励能比的。

考虑到南非大股东那边并没有停下抛售的脚步，企鹅此举应该是要把当年错卖的东西买回来。

同一天，出业绩的还有血汗工厂：拼多多。

拼多多 2023 年第四季度营收 889 亿元，同比增长 123%。

本来市场预期的 798 亿元，已经很高了，但业绩出来，还是超预期。

不管拼多多在国内是如何紧盯下沉市场，如何运用病毒式的社交传播，把自己做成了年轻人眼中鄙视链的底端，但事实就是事实，事实拼多多就是中概里最亮的星。

目前拼多多的海外版 temu 仍在大杀特杀，2023 的主要增长点是美国和日本。

temu 虽有中国血液，但和 TikTok 不同。TikTok 属于媒体类，temu 主要是生意，而且通常主力商户都是本土商家，而一个国家对海外媒体在本土做大做强，是很忌讳的。要么是怕影响自己的舆论霸权，要么是担心别人掌握舆论主导权。

...

回归主线。

来做一道和「拼多多」相关的算法原题。

题目描述

平台：LeetCode

题号：662

给你一棵二叉树的根节点 root，返回树的最大宽度。

树的「最大宽度」是所有层中最大的宽度。

每一层的宽度被定义为该层最左和最右的非空节点（即两个端点）之间的长度。

将这个二叉树视作与满二叉树结构相同，两端点间会出现一些延伸到这一层的 null 节点，这些 null 节点也计入长度。

题目数据保证答案将会在 32 位带符号整数范围内。

示例 1：

csharp 复制代码

输入：root = [1,3,2,5,3,null,9]

输出：4

解释：最大宽度出现在树的第 3 层，宽度为 4 (5,3,null,9) 。

示例 2：

csharp 复制代码

输入：root = [1,3,2,5,null,null,9,6,null,7]

输出：7

解释：最大宽度出现在树的第 4 层，宽度为 7 (6,null,null,null,null,null,7) 。

示例 3：

ini 复制代码

输入：root = [1,3,2,5]

输出：2

解释：最大宽度出现在树的第 2 层，宽度为 2 (3,2) 。

提示：

树中节点的数目范围是 <math xmlns="http://www.w3.org/1998/Math/MathML"> [ 1 , 3000 ] [1, 3000] </math>[1,3000]
<math xmlns="http://www.w3.org/1998/Math/MathML"> − 100 < = N o d e . v a l < = 100 -100 <= Node.val <= 100 </math>−100<=Node.val<=100

DFS

根据满二叉树的节点编号规则：若根节点编号为 u，则其左子节点编号为 u << 1，其右节点编号为 u << 1 | 1。

一个朴素的想法是：我们在 DFS过程中使用两个哈希表分别记录每层深度中的最小节点编号和最大节点编号，两者距离即是当前层的宽度，最终所有层数中的最大宽度即是答案。

而实现上，我们可以利用先 DFS 左节点，再 DFS 右节点的性质可知，每层的最左节点必然是最先被遍历到，因此我们只需要记录当前层最先被遍历到点编号（即当前层最小节点编号），并在 DFS 过程中计算宽度，更新答案即可。

看到评论区有同学讨论关于编号溢出问题，之所以溢出仍能 AC 是因为测试数组中没有同层内「宽度」左端点不溢出，右端点溢出，同时该层就是最大宽度的数据点。我们可以通过 u = u - map.get(depth) + 1 操作来对同层内的节点进行重新编号（使得同层最靠左的非空节点编号为 <math xmlns="http://www.w3.org/1998/Math/MathML"> 1 1 </math>1）。通过重编号操作我们可以消除由于深度加深带来的编号溢出问题，同时 TS 代码不再需要使用 bigint。

Java 代码：

Java 复制代码

class Solution {
    Map<Integer, Integer> map = new HashMap<>();
    int ans;
    public int widthOfBinaryTree(TreeNode root) {
        dfs(root, 1, 0);
        return ans;
    }
    void dfs(TreeNode root, int u, int depth) {
        if (root == null) return ;
        if (!map.containsKey(depth)) map.put(depth, u);
        ans = Math.max(ans, u - map.get(depth) + 1);
        u = u - map.get(depth) + 1;
        dfs(root.left, u << 1, depth + 1);
        dfs(root.right, u << 1 | 1, depth + 1);
    }
}

C++ 代码：

C++ 复制代码

class Solution {
public:
    unordered_map<int, int> map;
    int ans = 0;
    int widthOfBinaryTree(TreeNode* root) {
        dfs(root, 1, 0);
        return ans;
    }
    void dfs(TreeNode* root, int u, int depth) {
        if (!root) return;
        if (!map.count(depth)) map[depth] = u;
        ans = max(ans, u - map[depth] + 1);
        u = u - map[depth] + 1;
        dfs(root->left, u << 1, depth + 1);
        dfs(root->right, u << 1 | 1, depth + 1);
    }
};

Python 代码：

Python 复制代码

class Solution:
    def widthOfBinaryTree(self, root: Optional[TreeNode]) -> int:
        mapping = {}
        ans = 0
        def dfs(root, u, depth):
            nonlocal ans
            if not root: 
                return
            if depth not in mapping: 
                mapping[depth] = u
            ans = max(ans, u - mapping[depth] + 1)
            u = u - mapping[depth] + 1
            dfs(root.left, u << 1, depth + 1)
            dfs(root.right, u << 1 | 1, depth + 1)
        dfs(root, 1, 0)
        return ans

TypeScript 代码：

TypeScript 复制代码

let map = new Map<number, number>()
let ans = 0
function widthOfBinaryTree(root: TreeNode | null): number {
    map.clear()
    ans = 0
    dfs(root, 1, 0)
    return ans
};
function dfs(root: TreeNode | null, u: number, depth: number): void {
    if (root == null) return 
    if (!map.has(depth)) map.set(depth, u)
    ans = Math.max(ans, u - map.get(depth) + 1)
    u = u - map.get(depth) + 1
    dfs(root.left, u << 1, depth + 1)
    dfs(root.right, u << 1 | 1, depth + 1)
}

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

最后

给大伙通知一下 📢 ：

全网最低价 LeetCode 会员目前仍可用，快来薅羊毛！！！

📅 年度会员：有效期加赠两个月！！ ; 季度会员：有效期加赠两周！！

🧧 年度会员：获 66.66 现金红包！！ ; 季度会员：获 22.22 现金红包！！

🎁 年度会员：参与当月丰厚专属实物抽奖（中奖率 > 30%)！！

专属链接：leetcode.cn/premium/?pr...

更多详情请戳这里。

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

欢迎关注，明天见。

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