Learning Goals

• Understand the Dynamic Programming paradigm.
• Identify Optimal Substructure and Overlapping Subproblems.
• Master Memoization (top-down) vs Tabulation (bottom-up).
• Apply DP to Fibonacci and Rod Cutting.
• Learn the 4-step DP design recipe.

Origins and Definition

• Coined by Richard Bellman (1950s) — same Bellman from Bellman-Ford!
• Not 'dynamic' in the sense of motion, not 'programming' as coding.
• Refers to tabular planning — solving problems by filling in a table.
• Core Idea: Solve complex problems by breaking into simpler subproblems and storing their solutions.

Two Key Properties

• 1. Optimal Substructure: Optimal solution contains optimal solutions to subproblems.
• (We already saw this in shortest paths!)
• 2. Overlapping Subproblems: The recursive solution solves the SAME subproblems repeatedly.
• (Divide & Conquer has disjoint subproblems — DP has shared ones.)

DP vs Greedy vs Divide & Conquer

• Greedy: Make one locally optimal choice at each step. Fast but doesn't always work.
• Divide & Conquer: Split into independent subproblems (e.g., Merge Sort).
• DP: Explore all subproblem combinations but avoid redundant work by caching results.
• DP is more powerful than Greedy — it considers all options, not just the locally best one.

Interactive Demo: Recursion Tree

🚀 Interactive Demo: recursion_tree_demo.html

The Problem

• Fibonacci: $F_0 = 0$, $F_1 = 1$, $F_n = F_{n-1} + F_{n-2}$.
• Naive recursion: each call spawns two more calls.
• Exponential blowup: $T(n) = O(1.618^n)$ — the golden ratio.

Naive Recursive Fibonacci

Fib(n)
  if n <= 1 return n
  return Fib(n-1) + Fib(n-2)

Overlapping Subproblems

• Fib(5) calls Fib(4) and Fib(3).
• Fib(4) calls Fib(3) and Fib(2).
• Fib(3) is computed twice, Fib(2) is computed three times!
• Total calls grow exponentially: $O(\phi^n)$ where $\phi \approx 1.618$.
• Key insight: there are only $n+1$ distinct subproblems.

The Idea

• Keep the recursive structure, but cache results in a table (memo).
• Before computing, check: is $F(n)$ already stored?
• If yes, return the cached value. If no, compute, store, and return.
• Time: $O(n)$ — each subproblem computed only once. Space: $O(n)$.

Memoized Fibonacci

Map memo
Fib(n)
  if n in memo return memo[n]
  if n <= 1 f = n
  else f = Fib(n-1) + Fib(n-2)
  memo[n] = f
  return f

Interactive Demo: DP Fibonacci

🚀 Interactive Demo: dp_fibonacci_demo.html

The Idea

• Avoid recursion entirely. Fill table from base cases upward.
• $F[0]=0$, $F[1]=1$.
• For $i = 2$ to $n$: $F[i] = F[i-1] + F[i-2]$.
• No recursion overhead (no stack). Same $O(n)$ time.
• Can optimize space to $O(1)$ — only need last two values!

Memoization vs Tabulation

• Memoization (top-down): natural recursive thinking, only computes needed subproblems.
• Tabulation (bottom-up): iterative, computes all subproblems, often faster in practice.
• Both achieve polynomial time from exponential naive recursion.
• Choice is often a matter of taste — tabulation is usually preferred for its efficiency.

Interactive Demo: Rod Cutting

🚀 Interactive Demo: rod_cutting_demo.html

Problem Statement

• Given a rod of length $n$ inches.
• Table of prices $p_i$ for piece of length $i$ $(i=1,\ldots,n)$.
• Goal: Determine maximum revenue by cutting and selling pieces.

Example Data

• Length $i$: 1 2 3 4 5 6 7 8
• Price $p_i$: 1 5 8 9 10 17 17 20
• Rod $n=4$: No cut → $9. Cut 2+2 → $5+$5 = $10 (optimal). Cut 1+3 → $9. Cut 1+1+1+1 → $4.

Recursive Formulation

• Make a first cut of length $i$ ($1 \leq i \leq n$).
• Revenue = $p_i$ + MaxRevenue($n-i$).
• Maximize over all possible first cuts:
• $$r_n = \max_{1 \leq i \leq n} (p_i + r_{n-i})$$
• Base case: $r_0 = 0$ (empty rod).

Cut-Rod (Naive Recursive)

Cut-Rod(p, n)
  if n == 0 return 0
  q = -infinity
  for i = 1 to n
    q = max(q, p[i] + Cut-Rod(p, n-i))
  return q

Analysis of Naive Approach

• Recurrence: $T(n) = 1 + \sum_{j=0}^{n-1} T(j)$.
• Solution: $T(n) = 2^n$ — exponential!
• Why? Re-solving the same subproblems (lengths) over and over.
• Only $n+1$ distinct subproblems — classic DP opportunity.

Bottom-Up-Cut-Rod

let r[0..n] be new array
r[0] = 0
for j = 1 to n
  q = -infinity
  for i = 1 to j
    q = max(q, p[i] + r[j-i])
  r[j] = q
return r[n]

Complexity

• Outer loop: $j = 1$ to $n$.
• Inner loop: $i = 1$ to $j$.
• Total iterations: $1 + 2 + \ldots + n = \Theta(n^2)$.
• Massive improvement: from $2^n$ to $\Theta(n^2)$!

Finding the Actual Cuts

• So far we only compute the maximum revenue, not the cuts.
• Store the optimal first-cut length $s[j]$ for each size $j$.
• After computing, backtrack: print $s[n]$, then recurse on $n - s[n]$.

Extended-Bottom-Up-Cut-Rod

let r[0..n], s[0..n] be new arrays
r[0] = 0
for j = 1 to n
  q = -infinity
  for i = 1 to j
    if q < p[i] + r[j-i]
      q = p[i] + r[j-i]
      s[j] = i  // best first cut for size j
  r[j] = q
return r, s

Print-Cut-Rod-Solution

(r, s) = Extended-Bottom-Up-Cut-Rod(p, n)
while n > 0
  print s[n]
  n = n - s[n]

Visualizing Dependencies

• Draw a node for each subproblem ($0, 1, \ldots, n$).
• Draw edge $j \to (j-i)$ if subproblem $j$ depends on subproblem $j-i$.
• This forms a DAG (directed acyclic graph).
• Bottom-up DP processes vertices in reverse topological order.
• DP running time = number of edges in the subproblem graph.

4 Steps of DP

• Step 1: Characterize the structure of an optimal solution.
• Step 2: Recursively define the value of an optimal solution (write the recurrence).
• Step 3: Compute the value bottom-up (fill the table).
• Step 4: Construct the optimal solution from computed information (backtrack).

Recognizing DP Problems

• Look for optimization (maximize/minimize something).
• Check for optimal substructure: can you express the optimal solution in terms of subproblems?
• Check for overlapping subproblems: does naive recursion recompute the same thing?
• If yes to all three → DP is likely the right approach.

Watch Out For...

• Forgetting base cases: Every recurrence needs initial values ($r_0 = 0$, $F_0 = 0$, etc.).
• Wrong subproblem ordering: Bottom-up must fill dependencies before they're needed.
• Not recognizing overlapping subproblems: If subproblems are disjoint, use Divide & Conquer instead.
• Off-by-one errors in table indexing — be careful with 0-indexed vs 1-indexed.
• Greedy ≠ DP: Greedy makes one irrevocable choice; DP explores all subproblem combinations.

All Interactive Demos

🚀 Interactive Demo: recursion_tree_demo.html
🚀 Interactive Demo: dp_fibonacci_demo.html
🚀 Interactive Demo: rod_cutting_demo.html

Lecture Summary

• Dynamic Programming solves problems exhibiting optimal substructure and overlapping subproblems.
• Memoization (top-down) caches recursive results; Tabulation (bottom-up) fills a table iteratively — both avoid exponential redundancy.
• Rod Cutting demonstrates the full DP design: recurrence $r_n = \max(p_i + r_{n-i})$, bottom-up in $\Theta(n^2)$ vs naive $2^n$.
• 4-Step Recipe: Characterize structure → Define recurrence → Compute values → Reconstruct solution.
• Next lecture: applying DP to the 0/1 Knapsack problem.

Supplementary Resources

🚀 Interactive Demo: worked_examples.html
🚀 Interactive Demo: reading_practice.html
🚀 Interactive Demo: handout.html