LeetCode 1644. Lowest Common Ancestor of a Binary Tree II

原题链接在这里：https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree-ii/

题目：

Given the root of a binary tree, return the lowest common ancestor (LCA) of two given nodes, p and q. If either node p or q does not exist in the tree, return null. All values of the nodes in the tree are unique.

According to the definition of LCA on Wikipedia: "The lowest common ancestor of two nodes p and q in a binary tree T is the lowest node that has both p and q as descendants (where we allow a node to be a descendant of itself)". A descendant of a node x is a node y that is on the path from node x to some leaf node.

Example 1:

Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
Output: 3
Explanation: The LCA of nodes 5 and 1 is 3.

Example 2:

Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
Output: 5
Explanation: The LCA of nodes 5 and 4 is 5. A node can be a descendant of itself according to the definition of LCA.

Example 3:

Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 10
Output: null
Explanation: Node 10 does not exist in the tree, so return null.

Constraints:

• The number of nodes in the tree is in the range [1, 104].
• -109 <= Node.val <= 109
• All Node.val are unique.
• p != q

题解：

The difference between this question and Lowest Common Ancestor of a Binary Tree is that the assumption p and q exist in the tree changes.

Without this assumption, we need to traverse the whole tree and record if we incounter p and q. 

Since we need to treaverse the whole tree, we need to first call the recursive function. Then check if root == p || root == q.

If the condition fulfills, we need to increment the count by 1.

Time Complexity: O(n). n is the number of nodes in the tree.

Space: O(logn).

AC Java:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int count = 0;
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        TreeNode res = dfs(root, p, q);
        return count == 2 ? res : null;
    }
    
    private TreeNode dfs(TreeNode root, TreeNode p, TreeNode q){
        if(root == null){
            return null;
        }
        
        TreeNode left = dfs(root.left, p, q);
        TreeNode right = dfs(root.right, p, q);
        if(root == p || root == q){
            count++;
            return root;
        }
        
        if(left == null){
            return right;
        }
        
        if(right == null){
            return left;
        }
        
        return root;
    }
}

AC C++:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
    int count = 0;
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        TreeNode* res = dfs(root, p, q);
        return count == 2 ? res : nullptr;
    }

    TreeNode* dfs(TreeNode* root, TreeNode* p, TreeNode* q){
        if(!root){
            return root;
        }

        TreeNode* l = dfs(root->left, p, q);
        TreeNode* r = dfs(root->right, p, q);
        if(root == p || root == q){
            count++;
            return root;
        }

        if(!l){
            return r;
        }

        if(!r){
            return l;
        }

        return root;
    }
};

AC Python:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        self.count = 0
        res = self.dfs(root, p, q)
        return res if self.count == 2 else None
    
    def dfs(self, root, p, q):
        if not root:
            return root
        
        l = self.dfs(root.left, p, q)
        r = self.dfs(root.right, p, q)
        if root == p or root == q:
            self.count += 1
            return root
        if not l:
            return r
        if not r:
            return l
        return root

类似Lowest Common Ancestor of a Binary Tree.

跟上Lowest Common Ancestor of a Binary Tree III.