Introduction

In this blog post, we will explore how to solve the LeetCode problem "1123" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

Problem Statement

Given the root of a binary tree, return the lowest common ancestor of its deepest leaves. Recall that: The node of a binary tree is a leaf if and only if it has no children The depth of the root of the tree is 0. if the depth of a node is d, the depth of each of its children is d + 1. The lowest common ancestor of a set S of nodes, is the node A with the largest depth such that every node in S is in the subtree with root A. Example 1: Input: root = [3,5,1,6,2,0,8,null,null,7,4] Output: [2,7,4] Explanation: We return the node with value 2, colored in yellow in the diagram. The nodes coloured in blue are the deepest leaf-nodes of the tree. Note that nodes 6, 0, and 8 are also leaf nodes, but the depth of them is 2, but the depth of nodes 7 and 4 is 3. Example 2: Input: root = [1] Output: [1] Explanation: The root is the deepest node in the tree, and it's the lca of itself. Example 3: Input: root = [0,1,3,null,2] Output: [2] Explanation: The deepest leaf node in the tree is 2, the lca of one node is itself. Constraints: The number of nodes in the tree will be in the range [1, 1000]. 0 <= Node.val <= 1000 The values of the nodes in the tree are unique. Note: This question is the same as 865: https://leetcode.com/problems/smallest-subtree-with-all-the-deepest-nodes/

Explanation

Here's the solution to find the lowest common ancestor of the deepest leaves in a binary tree:

• High-Level Approach:

  • Perform a depth-first search (DFS) to determine the maximum depth of the tree.
  • During the DFS, also identify the LCA of the deepest leaves. If the left and right subtrees both contain deepest leaves, the current node is the LCA. If only one subtree contains deepest leaves, the LCA is within that subtree.
  • Return the LCA.

• Complexity:

  • Runtime: O(N), where N is the number of nodes in the tree.
  • Storage: O(H), where H is the height of the tree (call stack for recursion). In the worst case (skewed tree), H can be N. In the best case (balanced tree), H is log(N).

Code

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

class Solution:
    def lcaDeepestLeaves(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        """
        Finds the lowest common ancestor of the deepest leaves in a binary tree.

        Args:
            root: The root of the binary tree.

        Returns:
            The lowest common ancestor of the deepest leaves.
        """

        def deepest_leaves_lca_helper(node):
            """
            Helper function to recursively find the LCA of deepest leaves.

            Returns:
                A tuple containing:
                - The depth of the subtree rooted at the current node.
                - The LCA of the deepest leaves in the subtree.
            """
            if not node:
                return 0, None

            left_depth, left_lca = deepest_leaves_lca_helper(node.left)
            right_depth, right_lca = deepest_leaves_lca_helper(node.right)

            if left_depth == right_depth:
                return left_depth + 1, node
            elif left_depth > right_depth:
                return left_depth + 1, left_lca
            else:
                return right_depth + 1, right_lca

        _, lca = deepest_leaves_lca_helper(root)
        return lca