LeetCode-Python-1123. 最深叶节点的最近公共祖先

给你一个有根节点的二叉树，找到它最深的叶节点的最近公共祖先。

回想一下：

• 叶节点 是二叉树中没有子节点的节点
• 树的根节点的 深度 为 0，如果某一节点的深度为 d，那它的子节点的深度就是 d+1
• 如果我们假定 A 是一组节点 S 的 最近公共祖先，<font color="#c7254e" face="Menlo, Monaco, Consolas, Courier New, monospace">S</font> 中的每个节点都在以 A 为根节点的子树中，且 A 的深度达到此条件下可能的最大值。

 

示例 1：

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

示例 2：

输入：root = [1,2,3,4]
输出：[4]

示例 3：

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

 

提示：

• 给你的树中将有 1 到 1000 个节点。
• 树中每个节点的值都在 1 到 1000 之间。

思路：

先找到所有的最深叶节点，

怎么找最深叶节点？用DFS搜索整颗树，搜索的过程中建立哈希表记录每个节点的深度，key是节点地址，val是深度。

搜完之后就知道最深的深度，然后遍历哈希表，找到所有的最深叶节点。

然后判断一下，如果只有一个最深叶节点，那么最近公共祖先就是它自己，

如果有两个最深叶节点，那么题目就变成LeetCode-Python-236. 二叉树的最近公共祖先，

如果有多个最深叶节点，那么先把前两个最深叶节点的最近公共祖先找到，

然后让这个【最近公共祖先】跟剩下的每个最深叶节点找【最近公共祖先】。

class Solution(object):
    def lcaDeepestLeaves(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root or (not root.left and not root.right):
            return root
        
        dic = {}
        def depth(node, tmp):
            if not node:
                return
            dic[node] = tmp + 1
            depth(node.left, tmp + 1)
            depth(node.right, tmp + 1)
            
        depth(root, 0)

        l = []
        max_depth = max(dic.values())
        for key, val in dic.items():
            if val == max_depth:
                l.append(key)
                
        if len(l) == 1:
            return l[0]
        # print l
        tmpAncestor = None
        if len(l) >= 2:
            tmpAncestor = self.lowestCommonAncestor(root, l[0], l[1])
        for i in range(2, len(l), 1):
            tmpAncestor = self.lowestCommonAncestor(root, tmpAncestor, l[i])
        return tmpAncestor
   
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        
        if not root or root == p or root == q:
            return root
        else:
            left = self.lowestCommonAncestor(root.left, p, q)
            right = self.lowestCommonAncestor(root.right, p, q)
            
            if left and right: #一个在左子树，一个在右子树
                return root
            elif left:#都在左子树
                return left
            elif right:#都在右子树
                return right
            else:
                return