<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p>

<p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: &ldquo;The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).&rdquo;</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" />
<pre>
<strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
<strong>Output:</strong> 3
<strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3.
</pre>

<p><strong class="example">Example 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" />
<pre>
<strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
<strong>Output:</strong> 5
<strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.
</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> root = [1,2], p = 1, q = 2
<strong>Output:</strong> 1
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li>
	<li><code>-10<sup>9</sup> &lt;= Node.val &lt;= 10<sup>9</sup></code></li>
	<li>All <code>Node.val</code> are <strong>unique</strong>.</li>
	<li><code>p != q</code></li>
	<li><code>p</code> and <code>q</code> will exist in the tree.</li>
</ul>

# 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':
        node_to_parent : dict['TreeNode', 'TreeNode'] = {root:None}

        def add_children(node: 'TreeNode'):
            if node.right:
                node_to_parent[node.right] = node

            if node.left:
                node_to_parent[node.left] = node

        queue = [root]
        seen = set()
        seen.add(root)

        while queue:
            current = queue.pop()
            add_children(current)

            if current.right and current.right not in seen:
                queue.append(current.right)
                seen.add(current.right)
            if current.left and current.left not in seen:
                queue.append(current.left)
                seen.add(current.left)

        p_ancestors = set()
        q_ancestors = set()
        curr_p_ancestor = p
        curr_q_ancestor = q

        while True:
            if curr_p_ancestor == curr_q_ancestor:
                return curr_q_ancestor
            if curr_q_ancestor in p_ancestors:
                return curr_q_ancestor
            if curr_p_ancestor in q_ancestors:
                return curr_p_ancestor

            p_ancestors.add(curr_p_ancestor)
            q_ancestors.add(curr_q_ancestor)

            curr_p_ancestor = node_to_parent.get(curr_p_ancestor)
            curr_q_ancestor = node_to_parent.get(curr_q_ancestor)

        print(f"No ancestor found")

            

        
20400