Learning Goals

• Revisit and compare DP, Greedy, and Divide & Conquer paradigms.
• Solve the 0/1 Knapsack problem using DP.
• Solve the Longest Common Subsequence (LCS) problem using DP.
• Consolidate the DP Design Pattern for formulating solutions.
• Learn how to optimize space complexity in DP tables.

Divide & Conquer

• Approach: Split problem into independent subproblems, solve recursively, combine.
• Subproblems: Disjoint. They do not share sub-subproblems.
• Example: Merge Sort, Quick Sort.
• Why not use it for everything? If subproblems overlap, D&C does redundant work (e.g., Naive Fibonacci exponential blowup).

Greedy Algorithms

• Approach: Make a locally optimal choice at each step without looking ahead.
• Subproblems: Solves one subproblem arising from the greedy choice.
• Example: Fractional Knapsack, Dijkstra's Algorithm.
• Pros/Cons: Very fast, but only works if the problem has the Greedy Choice Property. Often fails to find the global optimum.

Dynamic Programming

• Approach: Systematically explore all possibilities by combining solutions to smaller subproblems.
• Subproblems: Overlapping. DP saves solutions in a table to avoid recomputation.
• Decision Making: Solves subproblems first, then uses those results to make an informed, globally optimal choice.
• When to use: When Greedy fails, but the problem has Optimal Substructure and Overlapping Subproblems.

The Setup

• A thief breaking into a store with a knapsack (bag) of weight capacity $W$.
• There are $n$ items. Each item $i$ has a value $v_i$ and weight $w_i$.
• Constraint: You either take an item entirely or leave it (0/1). No fractions!
• Goal: Maximize total value without exceeding the weight $W$.

Why Greedy Fails Here

• Fractional Knapsack allows taking parts of an item. Solvable by greedy (sort by value/weight ratio).
• 0/1 Knapsack constraint ruins the greedy strategy.
• Example: Capacity $W=50$.
• Item 1: val $60, wt 10 (Ratio: 6).
• Item 2: val $100, wt 20 (Ratio: 5).
• Item 3: val $120, wt 30 (Ratio: 4).
• Greedy by ratio takes Item 1 + Item 2 = $160 (wt 30). Leaves 20 wt unused!
• Optimal: Take Item 2 + Item 3 = $220 (wt 50).

Defining the Subproblem

• Can we just use capacity $w$ as our state? No, we need to track which items are available.
• Key insight: Process items in a specific order $1, 2, \ldots, n$.
• State: Let $K[i][w]$ be the maximum value achievable using a subset of the first $i$ items with available capacity $w$.
• Our final answer will be $K[n][W]$.

The Recurrence

• Consider item $i$ and remaining capacity $w$. We have two choices:
• Case 1: Item is too heavy ($w_i > w$). We cannot take it.
• $K[i][w] = K[i-1][w]$
• Case 2: Item fits. We take the maximum of including or excluding it.
• Exclude $i$: $K[i-1][w]$
• Include $i$: $v_i + K[i-1][w - w_i]$
• $K[i][w] = \max(K[i-1][w],\; v_i + K[i-1][w - w_i])$

Interactive Demo: 0/1 Knapsack

🚀 Interactive Demo: knapsack_demo.html

Knapsack-DP Algorithm

Knapsack(v, w, n, W)
  let K[0..n][0..W] be a new table
  for i = 0 to n
    for current_w = 0 to W
      if i == 0 or current_w == 0
        K[i][current_w] = 0 // Base case
      else if w[i] <= current_w
        K[i][current_w] = max(K[i-1][current_w], 
                              v[i] + K[i-1][current_w - w[i]])
      else
        K[i][current_w] = K[i-1][current_w]
  return K[n][W]

Complexity Analysis

• Table has $(n+1)$ rows and $(W+1)$ columns.
• Filling each cell takes $O(1)$ time.
• Time Complexity: $O(nW)$.
• Space Complexity: $O(nW)$ to store the entire 2D table.

Optimizing Space

• Look closely at the recurrence: row $i$ only depends on row $i-1$.
• We don't need to keep rows $0$ through $i-2$ in memory!
• We can reduce space to $O(W)$ by keeping just a 1D array.
• Trick: Iterate capacity $w$ backwards (from $W$ down to $w_i$) to ensure we use values from the previous iteration, not newly overwritten ones.

Space-Optimized Knapsack

Knapsack-1D(v, w, n, W)
  let DP[0..W] be array initialized to 0
  for i = 1 to n
    for current_w = W down to w[i]
      DP[current_w] = max(DP[current_w], 
                          v[i] + DP[current_w - w[i]])
  return DP[W]

Problem Definition

• Given two sequences $X$ and $Y$, find the length of the longest subsequence present in both.
• A subsequence is a sequence that appears in the same relative order, but not necessarily contiguous.
• Example: $X =$ `ABCBDAB`, $Y =$ `BDCABA`
• Common subsequences: `AB`, `BCA`, `BCBA`, `BDAB`.
• The LCS is `BCBA` (or `BDAB`). Length = 4.

Defining the Subproblem

• Let $X[1..m]$ and $Y[1..n]$ be the two strings.
• Look at prefixes: $X[1..i]$ and $Y[1..j]$.
• State: Let $C[i][j]$ be the length of the LCS of prefixes $X[1..i]$ and $Y[1..j]$.
• The final answer will be in $C[m][n]$.

The Recurrence

• Compare the last characters of the current prefixes: $X[i]$ and $Y[j]$.
• Case 1: Characters Match ($X[i] == Y[j]$)
• They must be part of the LCS! Add 1 to the LCS of the remaining prefixes.
• $C[i][j] = C[i-1][j-1] + 1$
• Case 2: Characters Differ ($X[i] \neq Y[j]$)
• The LCS cannot include both. It must be either without $X[i]$ or without $Y[j]$.
• $C[i][j] = \max(C[i-1][j], C[i][j-1])$
• Base Cases: $C[0][j] = 0$ and $C[i][0] = 0$.

LCS-Length Algorithm

LCS-Length(X, Y)
  m = length(X), n = length(Y)
  let C[0..m][0..n] be a new table
  
  for i = 0 to m: C[i][0] = 0
  for j = 0 to n: C[0][j] = 0
  
  for i = 1 to m
    for j = 1 to n
      if X[i] == Y[j]
        C[i][j] = C[i-1][j-1] + 1
      else
        C[i][j] = max(C[i-1][j], C[i][j-1])
        
  return C[m][n]

Interactive Demo: LCS Table

🚀 Interactive Demo: lcs_demo.html

Reconstructing the String

• The table gives us the length. How do we get the actual string?
• Start at $C[m][n]$ and trace backwards.
• If $X[i] == Y[j]$, this character is in the LCS. Prepend it and move diagonally to $(i-1, j-1)$.
• If $X[i] \neq Y[j]$, move in the direction of the larger value: either $(i-1, j)$ or $(i, j-1)$.
• Time to compute table: $O(mn)$. Time to reconstruct: $O(m+n)$.

The Universal 4-Step Recipe

• 1. Define the State: What is the subproblem? Usually prefixes ($i$), suffixes, or intervals ($i..j$).
• 2. Find the Recurrence: Express the solution to the state in terms of smaller subproblems. Make the choices explicit.
• 3. Identify Base Cases: What are the simplest, trivial instances? (e.g., length 0, capacity 0).
• 4. Determine Computation Order: Ensure smaller subproblems are solved before larger ones. Determine time/space complexity.

Common Pitfalls to Avoid

• Forcing Greedy when DP is needed: Always verify the Greedy Choice Property before skipping DP.
• Undefined Base Cases: Initializing matrices poorly leads to cascaded errors.
• Wrong Table Iteration Order: Especially important when doing space optimizations (like iterating backwards in 1D Knapsack).
• Forgetting Re-construction: Optimization problems ask for the value (length/cost), but often we need the choices (the actual string, the specific items).

Lecture Summary

• Paradigms: DP comprehensively searches subproblems, Greedy makes irreversible local choices, D&C handles disjoint subproblems.
• 0/1 Knapsack: Maximize value within weight limits. Recurrence uses $K[i][w]$. Time $O(nW)$. Can optimize to $O(W)$ space.
• LCS: Find longest shared subsequence. Recurrence matches characters ($+1$) or takes max of dropping from $X$ or $Y$. Time $O(mn)$.
• DP Recipe: Master the 4 steps (State, Recurrence, Base Cases, Order) to conquer any dynamic programming problem.

Supplementary Resources

🚀 Interactive Demo: knapsack_demo.html
🚀 Interactive Demo: lcs_demo.html
🚀 Interactive Demo: handout.html