每日一练：二叉树的最近公共祖先

236. 二叉树的最近公共祖先 - 力扣（LeetCode）

题目要求：

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

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

示例 1：

输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出：3
解释：节点 5 和节点 1 的最近公共祖先是节点 3 。

示例 2：

输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出：5
解释：节点 5 和节点 4 的最近公共祖先是节点 5 。因为根据定义最近公共祖先节点可以为节点本身。

示例 3：

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

解法-1 递归 O(N)

        我们可以通过寻找两个节点路径的公共部分来找到最近祖先，递归的思路如下：

        先找第一个节点的路径，如果某一条路径找到了该节点，说明这个节点在路径上，将节点加入哈希表后返回true；

        返回后由上层函数接收，若有true说明这个节点也在路径上，加入哈希表后继续返回true。。。。。。

        以此类推一直返回到根；

        再找第二个节点的路径，方法相同，但是一旦发现m[root] == 2，说明该节点就是最近祖先，因为1是上个节点的路径，2就是共同的路径。因为节点是从后往前遍历的，那么第一个等于2的节点就是最近共同祖先。

class Solution {
    bool _lowestCommonAncestor(TreeNode* root, TreeNode* target) {
        if (root == nullptr || ret != nullptr) // 走到空或者已经找到了就不用递归了
            return false;
        if (root == target) {
            m[root]++;
            if (m[root] == 2 && ret == nullptr)
                ret = root;
            return true;
        }
        bool result = _lowestCommonAncestor(root->left, target) ||
                      _lowestCommonAncestor(root->right, target);
        if (result) {
            m[root]++;
            if (m[root] == 2 && ret == nullptr)
                ret = root;
            return true;
        }
        return false;
    }

public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        _lowestCommonAncestor(root, p);
        _lowestCommonAncestor(root, q);
        return ret;
    }
private:
    TreeNode* ret = nullptr; // 保存最近的公共祖先
    unordered_map<TreeNode*, int> m; // 记录公共路径
};

解法-2 递归 O(N)

        题目说了没有重复节点，那么我们就可以找每一个节点之下的路径是否包含q和p，如果都包含就说明这个节点是公共祖先，又因为递归是从后往前操作节点的，那么找到的第一个公共祖先就是最近公共祖先。

        找一个节点的左右子树是否包含q、p，都包含就是答案；

        否则判断当前节点是不是q、p的其中一个，是的话再判断左右子树其中有没有q、p，有的话就是答案，没有的话因为该节点是q、p其中一个，所以返回true；

        如果都不是，只要当前节点的左右子树有q、p的其中一个就返回true。

class Solution {
    bool _lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == nullptr || result != nullptr)
            return false;
        bool F1 = _lowestCommonAncestor(root->left, p, q); // 找左子树
        bool F2 = _lowestCommonAncestor(root->right, p, q); // 找右子树
        if (F1 && F2) { // 都包含
            result = root;
            return false;
        }
        if (root == p || root == q) { // 当前节点是q、p其中一个
            if (F1 || F2)
                result = root;
            return true;
        }
        return F1 || F2; // 当前节点不是其中一个
    }

public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        _lowestCommonAncestor(root, p, q);
        return result;
    }
private:
    TreeNode* result = nullptr;
};