I front-loaded a bunch of clarifying questions before touching the code: can edges repeat, is the input guaranteed to actually form a valid tree, are both nodes guaranteed to exist, what if they're the same node.
Clarify that the tree is unrooted and edges are undirected, then choose an approach: either BFS from one node to find the other (O(N) time) or preprocess for LCA to answer multiple queries efficiently. For a single query, BFS is simpler; for multiple queries, LCA with binary lifting is better.
Pro tip: Mention that if the tree is large and multiple queries are expected, preprocessing for LCA is worth the O(N log N) setup, but for a single query BFS is optimal. Also, discuss handling edge cases like when the two nodes are the same or when one is an ancestor of the other.
Ask whether the tree is rooted or unrooted, if multiple queries will be made, and the expected input size. Confirm that edges are undirected and node values are unique.
For a single query, use BFS from one node to find the other, tracking distances. For multiple queries, preprocess the tree to answer LCA queries in O(1) or O(log N) after O(N log N) preprocessing.
If using BFS: build an adjacency list, perform BFS from the start node, and return the distance when the target is found. If using LCA: root the tree, compute depths and binary lifting table, then distance = depth[u] + depth[v] - 2*depth[lca(u,v)].
State time and space complexity: BFS is O(N) time and O(N) space; LCA preprocessing is O(N log N) time and space, with O(log N) per query (or O(1) with Euler tour + RMQ).
Test with small trees, same node, adjacent nodes, and nodes far apart. Discuss handling of large trees and potential recursion limits if using DFS for LCA preprocessing.
AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.