A page exists only when the idea does not survive as prose.
Sixteen interactive explanations built alongside a 12-week climb from plain recursion to dynamic programming. Each one exists because its idea is about when work happens or how often — and a code listing shows neither.
Four recursions with one skeleton. Move the work before or after the call and the answer arrives top-down or bottom-up. Print 1..N, print N..1, factorial, sum of digits — on one call stack.
Two pointers walking inward. Switch between comparing the ends and swapping them, and watch a single base case cover odd, even and empty strings.
The naive Fibonacci recursion tree. Click any node to light up every place that value is recomputed, then switch on memoization and watch 109 calls collapse to 17.
Twenty-eight steps through reverseList([1,2,3,4,5]). Five frames pile up changing nothing, then one link flips per return on the way back up.
A recursive merge picks each head on the way down and writes each link on the way back up. Flip <= to < and watch which list wins a tie.
Fast exponentiation reads n in binary: one digit per call on the way down, then builds xn from the 1-bits on the way back up. 32 calls for INT_MAX, where naive recursion needs 2.1 billion.
A Tower of Hanoi you can play for any number of disks, with a move counter against 2n − 1. Then watch the recursion solve it, and see each peg change role as the calls go deeper.
Preorder, inorder and postorder on the same tree, one moved line apart, with ans filling as it is passed down. Then LC 104, where nothing goes down and every depth comes back up from the empty subtrees, LC 112, where the remaining target goes down and a yes comes back, and LC 98, where each node gets the range its ancestors allow.
LC 226 with the subtrees sliding to their mirrored side as each call returns, including the moment the old left half is held only by a saved pointer. Then LC 100, walking two trees together until the first difference.
LC 206's leap of faith, two nodes at a time. Frames pile up without touching a pointer; on the way back each one rewires its pair, and at the end the nodes slide into their new order.
LC 543, where every call returns a height but the answer is a path kept on the side, and LC 236, where each subtree reports what it found and the answer is the first node to hear from both.
LC 78 as a decision tree, two ways: include/exclude and a for loop from a start index. The one shared cur vector grows on every push and shrinks on every pop. Then LC 77, three versions side by side, with every wasted call marked, LC 17, where nothing is wasted, LC 46, with a used array undone alongside cur, and LC 39, where a number may be picked again.
LC 79 on a grid: each cell on the path is marked # going in and given its letter back coming out, so the path can never loop. Then the #s a successful search leaves behind.
LC 93: each level chooses how many digits the next part takes, and most choices are turned down on the spot for a leading zero or a value over 255. The search grows as an outline, one row per call or rejection.
Merge sort one level at a time: splitting is free, each merge compares two fronts, and a counter on every row shows the merging done there. At most n per level, about log n levels: O(n log n) you can count.
LC 241: split at each operator in turn, solve both sides, combine every pair. A running count shows the same substrings being solved again and again: the repeated work the Month 1 checkpoint removes with a cache.
Next stop. The overlapping subproblems Fibonacci showed in Week 1, cached at last.
Twelve weeks, from recursion to bitmask and digit DP. Pages appear where an idea needs one.
LC 206 is where tracing stops working and trusting starts. You cannot hold five stack frames in your head, and the page makes that unnecessary: watch five frames pile up changing nothing, then one link flip per return.
LC 509 is where dynamic programming first becomes visible. At n = 30 the recursion makes 2,692,537 calls to compute 31 distinct values. That gap — between distinct subproblems and calls made — is the whole idea, arriving nine weeks before the word is needed.