Dynamic Programming, Visualized
Dynamic programming is a statement about repeated work: the same subproblem computed twice is wasted instructions. This video shows how memoization caches results at the call level and how tabulation fills a table in dependency order, so the state transition becomes visible data flow instead of abstract theory.
Topics covered:
- Overlapping subproblems: where brute force repeats work
- Memoization: caching function results as calls recurse
- Tabulation: filling the table in dependency order
- State definition: what a table cell actually represents
- Space optimization: keeping only the last two rows
- Classic patterns: knapsack, longest common subsequence, grid paths
Related articles
Dynamic Programming: Recursion to Tabulation
Transform exponential-time recursive solutions into polynomial-time tabular solutions, with space optimization techniques.
Big-O Measures Scaling, Not Speed
O(n) says nothing about how fast your code is today — it predicts how it behaves as the input grows. What complexity analysis is really for, and when it misleads.
Hash Tables Aren't Magic
Load factors, collision strategies, and cache misses — why O(1) has a constant that bites when you least expect it.
More in Algorithms
Hash Tables Under the Hood
Load factors, collision strategies, and cache behavior — why O(1) has a constant that can be 1ns or 200ns.
WatchTries and String Search
Tries, radix trees, and Aho-Corasick — how prefix structures make lookups proportional to key length, not dataset size.
DetailsHeaps and Priority Queues
Binary heaps as arrays — sift up, sift down, and why insert and extract-min are both O(log n) with no pointers.
DetailsHash Maps and Collision Resolution
Hash maps from the memory up — hash functions, collision strategies, and the load factor that decides when a map resizes.
DetailsGraph Algorithms: BFS and DFS
BFS and DFS traced node by node — the queue versus the stack, the visited set, and what each traversal order is good for.
DetailsBinary Search Explained
Binary search at the instruction level — midpoint math, cache behavior, and why it beats linear scan on sorted contiguous data.
DetailsRecursion and the Call Stack
How recursive functions actually execute — stack frames, the base case, and what happens to memory when recursion goes deep.
DetailsBig-O Notation, Visually Explained
What O(1), O(n), and O(log n) mean as instruction counts — growth curves drawn to scale, constants, and real workloads.
DetailsSorting Algorithms Under the Hood
Quicksort, merge sort, and insertion sort compared by the operations that matter: comparisons, swaps, cache misses, and allocations.
DetailsDepth, delivered weekly
One technical dispatch a week — articles and episode notes before they go public.
One technical dispatch per week. No noise.