Compare N-Ary Tree Leaf Sequences

Each N-ary tree is represented by parallel parent and values arrays. The root has parent -1; every other entry names its parent index. Children are ordered by node index. Return whether the two trees have identical leaf-value sequences from left to right. Use an iterative traversal.

Function
sameNaryLeafValues(parent1: int[], values1: int[], parent2: int[], values2: int[]) → boolean

Examples
Example 1
parent1 = [-1,0,0]
values1 = [1,2,3]
parent2 = [-1,0,0]
values2 = [7,2,3]
return = true
Both leaf sequences are [2,3].
Example 2
parent1 = [-1,0,0]
values1 = [1,2,3]
parent2 = [-1,0,0]
values2 = [1,3,2]
return = false
Leaf order differs.

Constraints
Each tree has between 1 and 200000 nodes.
Each input is a valid rooted tree with exactly one -1 parent.
Node values fit in a signed 32-bit integer.

The trick is that you never need to build a real tree. Children are ordered by node index, so a node is a leaf exactly when its index never appears in the parent array. Scan parent1 once, mark every index that shows up as a parent, then walk indices 0 to n-1 in order and collect values for unmarked ones. Index order among leaves gives you the left-to-right order. Do the same for tree two and compare the lists. That's O(n) with no recursion at all. The pitfall is assuming leaf order needs a DFS and then overflowing the stack at 200000 nodes. Another miss is comparing node values instead of only leaf values, since Example 1 has different roots but still returns true. Careful: this index-order shortcut holds only if left-to-right order matches index order, which the statement says it does. If you freeze live, StealthCoder is the hedge that gets you the linear scan.

Memorize the pattern. If you can't, run StealthCoder. The proctor sees the IDE. They don't see what's behind it.