华为分红出炉，人均超50w！

华为分红 770 亿

4 月 2 日，北京金融资产交易所官网发布了《华为投资控股有限公司关于分配股利的公告》。

公告指出：经公司内部有权机构决议，拟向股东分配股利约 770.945 亿元。

众所周知，华为并不是一家上市公司，这里的分红是指通过工会实行的「员工持股计划」。

截止至 2023 年底，华为员工持股计划参与人数约为 15W 人，因此本次分红人均 W。

真不错，又是心如止水的一天：

华为分红坚挺的背后，是 2023 年实现营业收入 7042 亿元，净利润 870 亿元，同比增长 144.5% 。

...

回归主线。

来一道和「华为-入门级-算法考试」相关的题目。

题目描述

平台：LeetCode

题号：235

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

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

例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]

示例 1:

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

输出: 6 

解释: 节点 2 和节点 8 的最近公共祖先是 6。

示例 2:

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

输出: 2

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

说明:

所有节点的值都是唯一的。
p、 q 为不同节点且均存在于给定的二叉搜索树中。

DFS

也是常见的 LCA 问题，但相比 236. 二叉树的最近公共祖先，本题搜索对象为二叉搜索树，利用此特性，我们可以将搜索复杂度从优化至。

利用原函数作为递归函数，复用 root 作为搜索过程中的当前节点，根据 root 和两节点关系进行分情况讨论：

若 root 为 p 和 q 中的任一节点：由于搜索过程是从上往下，因此 root 必然是距离两者垂直距离最远的最近公共祖先，返回 root；
否则根据 root 和 p、 q 的节点值大小进一步讨论，将 root 节点值记为 a，两节点值中的较小值记为 b，两节点中的较大值记为 c：
- 若有，说明 p 和 q 中值较小的节点在当前节点 root 的左子树内， p 和 q 中值较大的节点在当前节点 root 的右子树内。由于搜索过程是从上往下，因此 root 作为首个满足该条件的节点，必然是距离两者垂直距离最远的最近公共祖先，返回 root；
- 若有，说明两节点均在当前节点 root 的右子树内，递归处理 root.right；
- 若有，说明两节点均在当前节点 root 的左子树内，递归处理 root.left。

Java 代码：

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == p || root == q) return root;
        int a = root.val, b = Math.min(p.val, q.val), c = Math.max(p.val, q.val);
        if (a > b && a < c) return root;
        else if (a < b) return lowestCommonAncestor(root.right, p, q);
        else return lowestCommonAncestor(root.left, p, q);
    }
}

C++ 代码：

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == p || root == q) return root;
        int a = root->val, b = min(p->val, q->val), c = max(p->val, q->val);
        if (a > b && a < c) return root;    
        else if (a < b) return lowestCommonAncestor(root->right, p, q);    
        else return lowestCommonAncestor(root->left, p, q);
    }
};

Python 代码：

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if root == p or root == q:
            return root
        a, b = root.val, min(p.val, q.val)
        c = max(p.val, q.val)
        if a > b and a < c:
            return root
        elif a < b:
            return self.lowestCommonAncestor(root.right, p, q)
        else:
            return self.lowestCommonAncestor(root.left, p, q)

TypeScript 代码：

function lowestCommonAncestor(root: TreeNode | null, p: TreeNode | null, q: TreeNode | null): TreeNode | null {
    if (root === p || root === q) return root;
    const a = root.val, b = Math.min(p.val, q.val), c = Math.max(p.val, q.val);
    if (a > b && a < c) return root;
    else if (a < b) return lowestCommonAncestor(root.right, p, q);
    else return lowestCommonAncestor(root.left, p, q);
};