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

The result of the multiplication of a r₀ × r₁ matrix ₀M₁ and
a r₁ × r₂ matrix ₁M₂ (₀M₁· ₁M₂ ⇒ ₀M₁M₂)
is a r₀ × 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

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₃ or
₀M₁· (₁M₂ · ₂M₃)
(also written: ₀M₂M₃ or ₀M₁M₃)
For r₀=100, r₁=2, r₂=200, r₃=3, the number of scalar multiplications for each order of evaluation is:

(₀M₁· ₁M₂) · ₂M₃: 100×2×200 + 100×200×3 = 100,000
₀M₁· (₁M₂ · ₂M₃): 2×200×3 + 100×2×3 = 1,800

The number of orders for multiplying n matrices looks 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) and so on are frequent time complexities

Optimal substructure:
The global (optimal) solution can be constructed from the (optimal) solutions of subproblems
Overlapping subproblems (this is where dynamic programming differs from divide and conquer)
Memoization

To avoid repeatedly calling the same function with the same arguments, spending time again to calculate the same results, we modify the function so that:
- The result is stored (e.g. in a Hash) using the function arguments as the key
- Before the actual calculation, the storage is checked, and a previous result is returned if found, before actual calculation
This technique is called memoization
In Ruby, this can easily be implemented with metaprogramming
(metaprogramming: 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 these 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