/
lectern.tv
Play15s30s1x0:00/--:--
DoneWatched
Expand
lectern.tv
0:40/51:47
3:03
1:42
5:53
0:36
2:35
1:34
3:40
0:36
1:36
1:46
4:13
3:26
1:36
2:19
5:04
3:20
2:40
1:19
1:15
3:13
Dynamic Programming I: Fibonacci, Shortest Paths
Master the art of dynamic programming with Erik Demaine as he unpacks Fibonacci sequences, memoization, guessing, and shortest paths in graphs.
Lecture guide · Written by AI from the lecture. For the lecture’s own words, open the Transcript tab.
Introduces dynamic programming as a powerful algorithm design technique, breaking it down into recursion, memoization, and guessing through the examples of computing Fibonacci numbers and solving shortest paths. It details the transformation from naive exponential recursion to linear-time memoized and bottom-up approaches, and resolves cyclic graph issues in shortest paths via the Bellman-Ford parameterization.
This lecture assumes
Key Takeaways
- Dynamic programming is approximately a careful brute force that turns exponential-time searches into polynomial-time solutions.
- Dynamic programming can be viewed as recursion plus memoization plus guessing.
- The running time of a memoized algorithm can be calculated as the number of subproblems multiplied by the nonrecursive work per subproblem.
- For memoization to succeed, subproblem dependencies must form an acyclic structure (a DAG).
Concepts Explained12
Dynamic Programming—A general, powerful algorithm design technique that is especially good and intended for optimization problems, acting roughly as a careful brute force by breaking a problem into subproblems and reusing their solutions.
Fibonacci Numbers—A sequence defined by base cases F1 = F2 = 1 and the recurrence relation Fn = Fn-1 + Fn-2.
Memoization—A technique in dynamic programming where whenever a function is computed, its result is stored in a dictionary so that future calls with the same input return the stored result immediately instead of recomputing it.
Memoized DP Algorithm Running Time Analysis—The running time of a memoized algorithm is bounded by the product of the number of nonmemoized calls and the constant nonrecursive work per call.
Examples, Proofs & Derivations