Dynamic Programming

(動的計画法)

Data Structures and Algorithms

12th lecture, December 23, 2019

http://www.sw.it.aoyama.ac.jp/2019/DA/lecture12.html

Martin J. Dürst

© 2009-19 Martin J. Dürst 青山学院大学

Today's Schedule

• Leftovers and summary of last lecture
• Algorithm design strategies
• Overview of dynamic programming
• Example application: Order of evaluation of chain matrix multiplication
• Dynamic programming in Ruby

Leftovers and Summary of Last Lecture

(string matching context, string matching and character encoding)

Algorithm Design Strategies

• Simple/simplistic algorithms
• Divide and conquer
  
• Dynamic programming

Overview of Dynamic Programming

• Investigate and clarify the structure of the (optimal) solution
• Recursive definition of (optimal) solution
• Bottom-up calculation of (optimal) solution
• Construction of (optimal) solution from calculation results

• Proposed by Richard Bellman in the 1950ies
• Name now sounds arbitrary, but is firmly established

Simple Example of Dynamic Programming

• Definition of the Fibonacci function f(n):
  • n=0, n=1: f(n) = n
  • n ≧ 2: f(n) = f(n-1) + f(n-2)
• Implementation for this recursive definition is easy (see also Cfibonacci.rb):
  

  def fib (n)

      n<2 ? n : fib(n-1) + fib(n-2)

  end

• 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, or
  • Remembering intermediate results

Matrix Multiplication

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

Matrix Multiplication Program Skeleton

for (i=0; i<r0; i++)
    for (j=0; j<r2; j++) {
        sum = 0;
        for (k=0; k<r1; k++)
            sum += 0M1[i][k] * 1M2[k][j];
        0M2[i][j] = sum;
    }

Chain Multiplication of Reals

• A series of multiplications (e.g. 163·25·4) is called chain multiplication
• Multiplication of reals is associative (i.e. (163·25)·4 = 163·(25·4))
• Not all multiplication orders have the same speed.
  For humans, 163·(25·4) = 163·100 = 16300 is faster than (163·25)·4 = 4075·4
• Conclusion: Choosing a good multiplication order can speed up calculation

Chain Multiplication of Matrices

• Matrices can also be multiplied in chains (e.g. ₀M₁ · ₁M₂ · ₂M₃)
• Multiplication of matrices is associative (but not commutative!)
• 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
  

Number of Matrix Multiplications Orders

• 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 n pairs of properly nested parentheses (n=3: ()()(), (())(), ()(()), ((())), (()()))
  • Number of shapes of binary trees of size n
  • Number of triangulations of a (convex) polygon with n vertices

Optimal Order of Multiplications

• Checking all orders is very slow (Ω(n4ⁿ/n^3/2) = Ω(4ⁿ/n^1/2))
• Minimal evaluation cost (number of scalar multiplications):
  • mincost(a, c): minimal cost for evaluating _aM_c
    • if a+1 ≧ c, mincost(a, c) = 0
    • if a+1 < c, mincost(a, c) = min^c-1_b=a+1 cost(a, b, c)
      
  • split(a, c): optimal spliting point
    
    • split(a, c) = arg min_b cost(a, b, c)
  • cost(a, b, c): cost for calculating _aM_bM_c
    • i.e. cost for splitting the evaluation of _aM_c at b
    • cost(a, b, c) = mincost(a, b)+mincost(b, c) + r_ar_br_c
• Simple implementation in Ruby: MatrixSlow in Cmatrix.rb

Inverting Optimization Order and Storing Intermediate Results

• 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

Example Calculation

Complexity of Optimizing Evaluation Order

• The calculation of mincost(a, c) is O(c-a)
• Evaluating all mincost(a, a+k) is O((n-k)·k)
• Total time complexity: ∑ⁿ_k=1 O((n-k)·k) = O(n³)

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

Overview of Dynamic Programming

• Investigate and clarify the structure of the (optimal) solution
• Recursive definition of (optimal) solution (e.g. MatrixSlow)
• Bottom-up calculation of (optimal) solution (e.g. MatrixPlan)
• Construction of (optimal) solution from calculation results

Conditions for Using Dynamic Programming

• 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)

Memoization

• The key in dynamic programming is to reuse intermediate results
• Many functions can be changed so that they remember results
• This is called memoization:
  • Add a data structure that stores results
    (a dictionary with arguments as key and result as value)
  • Check the dictionary
  • If the result is stored, return it immediately
  • If the result is not stored, calculate it, store it, and return it
• Only possible for pure functions (no side effects)

Memoization in Ruby

• Use metaprogramming to modify a 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
• Metaprogramming changes the program while it runs
• Simple application example: Cfibonacci.rb

Summary

• 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

Homework

• Review this lecture (including the 'Example Calculation' and the programs)
• Find three problems that can be solved using dynamic programming, and investigate the algorithms used

Glossary

dynamic programming

動的計画法

algorithm design strategies

アルゴリズムの設計方針

optimal solution

最適解

Catalan number

カタラン数

matrix chain multiplication

連鎖行列積、行列の連鎖乗算

triangulations

(多角形の) 三角分割

(convex) polygon

(凸) 多角形

intermediate result

途中結果

splitting point

分割点

arg min (argument of the minimum)

最小値点

top-down

下向き、トップダウン

bottom-up

上向き、ボトムアップ

optimal substructure

部分構造の最適性

overlapping subproblems

部分問題の重複

memoization (verb: memoize)

履歴管理

metaprogramming

メタプログラミング