Lowest Common Ancestor in a Parent Tree

A rooted tree with nodes 0 through n - 1 is represented by parent. The root is node 0, parent[0] = -1, and for every other node i, parent[i] is its direct parent.
Given nodes p and q, return their lowest common ancestor: the common ancestor farthest from the root. A node is an ancestor of itself.

Function
lowestCommonAncestor(parent: int[], p: int, q: int) → int

Examples
Example 1
parent = [-1,0,0,1,1,2,2]
p = 3
q = 4
return = 1
Nodes 3 and 4 are both direct children of node 1.
Example 2
parent = [-1,0,0,1,1,2,2]
p = 3
q = 6
return = 0
The two nodes lie in different root subtrees.

Constraints
1 <= parent.length <= 100000.
parent[0] = -1.
For i > 0, 0 <= parent[i] < i.
0 <= p, q < parent.length.

The data structure is the parent array itself. Two clean approaches. First, build a set of every ancestor of p by walking up until you hit -1, then walk up from q and return the first node already in the set. That's O(n) time and O(n) space. Second, compute depths, lift the deeper node until both depths match, then move both up together until they meet. Since parent[i] < i, you can fill depth in a single forward pass with depth[i] = depth[parent[i]] + 1, no recursion needed. The common pitfall is recursing on a 100000 node chain and blowing the stack. Another is forgetting a node is its own ancestor, so p == q or p being an ancestor of q must return p. Keep it iterative. If your mind goes blank mid-assessment, StealthCoder is the hedge that gives you the solution in real time.

If this hits your live OA and you blank, StealthCoder solves it in seconds, invisible to the proctor.