Trees & BST

Obstacle cells get dp = 0; free cells sum paths from above and from the left; if start or end is blocked, the answer is 0.

A graph is a valid tree if and only if it has exactly n-1 edges and is fully connected; verify with a single traversal or Union-Find.

A binary tree is a hierarchical data structure where every node has at most two children, a left and a right, under a single root.

Inorder visits left-node-right (sorted on BST), preorder visits node-left-right (clone/serialize), postorder visits left-right-node (delete/evaluate).

DFS dives down one path as deep as possible, then backtracks to try the next unexplored branch, using recursion or a stack.

The count of unique BSTs over N nodes equals the sum over each root of left-count times right-count, which is the Catalan number recurrence.

A trie stores characters on edges so every path from root spells a prefix, and all operations cost only the key length.

dp[i][j] equals the cell's own cost plus the minimum of the cost from above and the cost from the left.

A trie stores characters along edges so every key operation costs only the length of the key, and the Trie pattern uses this for prefix-based lookups.

Use a queue, snapshot the level size, drain exactly that many nodes while enqueuing their children, producing one list per level.

Standard BFS with a direction flag per level: append on left-to-right levels, prepend on right-to-left levels.

BFS level by level; return the depth the moment you dequeue a leaf, because BFS guarantees the nearest leaf is found first.

BFS: count the number of levels processed; DFS: return 1 + max(left depth, right depth).

BFS per level: link each dequeued node's `next` to the node dequeued right after it; the last node of each level keeps `next` as null.

BFS without level breaks: link every dequeued node's `next` to the very next dequeued node across all levels, forming one continuous chain.

Walk each root-to-leaf path depth-first, subtract each node's value from the target, and return true when a leaf makes the remainder exactly zero.

Depth-first with a running path list: copy the path at every matching leaf, and backtrack by removing the last node on the way back up.

Match node values against the sequence by index as you descend, and succeed only when a leaf lands exactly at the end of the sequence.

The depth of a node is one plus the maximum depth of its two children, and a null child contributes zero.

Two trees are the same if both nodes are null, or both are non-null with equal values and identical left and right subtrees.

At every node swap its two children, then recursively invert both subtrees to produce the mirror image.

Recurse both sides; if each side finds one target, the current node is the lowest common ancestor, otherwise pass up whichever side found something.

Preorder gives the next root, inorder splits that root into left and right subtrees, and recursion rebuilds the whole tree.

Write preorder with explicit null markers to serialize, and read the same preorder with those markers to deserialize into the identical tree.

Path Sum subtracts toward a leaf; Path Sum III uses a running prefix sum and a HashMap so each node counts matching downward paths in constant time.