Method 1: 自己想的，先找到deepest leaves，再用lca
    Method 2: 记录depth，左右子树depth一样说明左右都有以当前节点为root的deepest leaves 所以lca就是root， 然后递归调用

    Method 1：

    1. # Definition for a binary tree node.
    2. # class TreeNode:
    3. #     def __init__(self, val=0, left=None, right=None):
    4. #         self.val = val
    5. #         self.left = left
    6. #         self.right = right
    7. class Solution:
    8.     def lcaDeepestLeaves(self, root: TreeNode) -> TreeNode:
    9.         def lca(root: TreeNode, nodes: list):
    10.             if root == None or root in nodes:
    11.                 return root
    12.             #if len(nodes) == 1:
    14.             left = lca(root.left, nodes)
    15.             right = lca(root.right, nodes)
    17.             if left != None and right != None:
    18.                 return root
    19.             elif left != None:
    20.                 return left
    21.             elif right != None:
    22.                 return right
    23.             else:
    24.                 return None
    27.         if root == None:
    28.             return None
    29.         queue = [root]
    30.         while queue:
    31.             size = len(queue)
    32.             level = []
    33.             for i in range(size):
    34.                 node = queue.pop(0)
    35.                 level.append(node)
    36.                 if node.left:
    37.                     queue.append(node.left)
    38.                 if node.right:
    39.                     queue.append(node.right)
    40.         print(level)
    41.         return lca(root, level)

    Method 2:

    1. def lcaDeepestLeaves(self, root):
    2.         def helper(root):
    3.             if not root: return 0, None
    4.             h1, lca1 = helper(root.left)
    5.             h2, lca2 = helper(root.right)
    6.             if h1 > h2: return h1 + 1, lca1
    7.             if h1 < h2: return h2 + 1, lca2
    8.             return h1 + 1, root
    9.         return helper(root)[1]