Simple Python BFS + LCA Solution; faster than 98.7% at the time of writing
Understanding of the Problem:\n\n Find the nodes at the deepest level in the tree. It can be just one node with the maximum depth. There can be many nodes with 
**Understanding of the Problem:**\n\n* Find the nodes at the deepest level in the tree. It can be just one node with the maximum depth. There can be many nodes with the same maximum depth, i.e. the same level in BFS.\n\n* The problem asks for the common parent node of these deepest nodes.\n\t* In case when there is just one deepest node, it is the result.\n\t* In case there are many nodes at the deepest level, the result is the Least Common Ancestor(LCA) of the leftmost and the rightmost nodes.\n\n**Solving**\n\n* Use BFS to find the left-most and right-most deepest nodes. In the queue, the tuple (node,depth) is pushed to keep track of every level. All the next levels of node are marked with depth+1\n\n* Keep track of maximum depth. ``` depth > max_depth```  takes care of storing the leftmost deepest node. ``` depth >= max_depth ``` takes care of storing the rightmost deepest node. The *equals*  helps to keep on updating the last one at the same level.\n\n* Once you have the two nodes, simply return their LCA.\n\n```\ndef subtreeWithAllDeepest(self, root):\n        """\n        :type root: TreeNode\n        :rtype: TreeNode\n        """\n        \n        # Find left-most deepest(lmd) node\n        # Find right-most deepest(rmd) node\n        # Find LCA of those two\n        \n        lmd = rmd = root\n        from collections import deque\n        q = deque()\n        q.append((root,0)) # (TreeNode, depth)\n        max_depth = 0\n        while q:\n            \n            node, depth = q.popleft()\n            if depth>max_depth:\n                max_depth = depth\n                lmd = node\n            if depth>=max_depth:\n                max_depth = depth\n                rmd = node\n            if node.left:\n                q.append((node.left, depth+1))\n            if node.right:\n                q.append((node.right, depth+1))\n        \n        if lmd is rmd:\n            return lmd\n        return self.lca(root, lmd, rmd)\n    \n    def lca(self, root, lmd, rmd):\n        \n        if not root:\n            return None\n        if root.val==lmd.val or root.val==rmd.val:\n            return root\n        \n        lh = self.lca(root.left, lmd, rmd)\n        rh = self.lca(root.right, lmd, rmd)\n        \n        if lh and rh:\n            return root\n        if lh and not rh:\n            return lh\n        if rh and not lh:\n            return rh\n        return None\n```\n\n*Above code can definitely have some optimizations.* I just shared my idea+implementation.\n
[]