Dynamic Programming

(動的計画法)

Data Structures and Algorithms

(Boyer-Moore algorithm, string matching and character encoding)

Proposed by Richard Bellman in the 1950ies

Definition of the Fibonacci function f(n):
- 0 ≦ n ≦ 1: f(n) = n
- n ≧ 2: f(n) = f(n-1) + f(n-2)
Implementation for this recursive definition is easy
If n grows, execution gets extremely slow
Reason for slow execution: The same calculation is repeated many times
(when evaluating f(n), f(1) is evaluated f(n) times)
Evaluation time can be shortened by changing the order of evaluations and remembering intermediate results

Multiplying a r₀ by r₁ matrix ₀M₁ and
a r₁ by r₂ matrix ₁M₂ (₀M₁· ₁M₂ ⇒ ₀M₁M₂)
results in a r₀ by r₂ matrix ₀M₂
This multiplication needs r₀r₁r₂ scalar multiplications and r₀(r₁-1)r₂ scalar additions,
so its time complexity is O(r₀r₁r₂)
Because the number of scalar multiplications and additions is almost the same, we will only consider multiplications
Actual example: r₀=100, r₁=2, r₂=200
⇒ Number of multiplications: 100×2×200 = 40,000

for (i=0; i<r₀; i++)
  for (j=0; j<r₂; j++) {
    sum = 0;
    for (k=0; k<r₁; k++)
      sum += ₀M₁[i][k] * ₁M₂[k][j];
    ₀M₂[i][j] = sum;
  }

Multiplication of three (or more) matrices: ₀M₁ · ₁M₂· ₂M₃
Multiplication of matrices is associative
This means that there are multiple ways to calculate the overall product:
(₀M₁·₁M₂) · ₂M₃ (also written ₀M₂M₃) or
₀M₁ · (₁M₂·₂M₃) (also written ₀M₁M₃)
For r₀=100, r₁=2, r₂=200, r₃=3, the number of scalar multiplications is:

(₀M₁·₁M₂) · ₂M₃: 100×2×200 + 100×200×3 = 100,000
₀M₁ · (₁M₂·₂M₃): 2×200×3 + 100×2×3 = 1,800
Conclusion: Choosing a good order for matrix multiplications can save a lot of work

The number of orders for multiplying n matrices is small for small n, but grows exponentially
The number of orders is equal to the numbers in the middle of Pascal's triangle (1, 2, 6, 20, 70,...)
divided by increasing natural numbers (1, 2, 3, 4, 5,...)
These numbers are called Catalan numbers:
C_n = (2n)!/(n!(n+1)!) = Ω(4ⁿ/n^3/2)
Catalan numbers have many applications:
- Combinations of paired parentheses
- Number of shapes of binary trees
- Number of triangulations of a (convex) polygon

The solution can be evaluated from split(0, n) top-down using recursion
The problem with top-down evaluation is that intermediate results (mincost(x, y)) are calculated repeatedly
Bottom-up calculation:
- Calculate the minimal costs and splitting points for chains of length k, starting with k=2 and increasing to k=n
- Store intermediate results for reuse
Implementation in Ruby: MatrixPlan in Cmatrix.rb

The time complexity of dynamic programming depends on the structure of the problem

O(n³), O(n²), O(n), O(nm),... are frequent time complexities

Optimal substructure:
The global (optimal) solution can be constructed from the (optimal) solutions of subproblems
(common with divide and conquer)
Overlapping subproblems
(different from divide and conquer)

Modify function so that:
- On first calculation, result is stored (e.g. in a Hash using function arguments as the key)
- Before each calculation, storage is checked, and stored result used if available
This avoids useless recalculations
Only possible for pure functions (no side effects)
This is called memoization
In Ruby, implementable with metaprogramming
(i.e.: changing the program while it runs)
Simple application example: Cfibonacci.rb

Dynamic programming is an algorithm design strategy
Dynamic programming is suited for problems where the overall (optimal) solution can be obtained from solutions for subproblems, but the subproblems overlap
The time complexity of dynamic programming depends on the structure of the actual problem

Review this lecture
Find three problems that can be solved using dynamic programming, and investigate the algorithms used