Dynamic Programming

• A method of solving complex problems by breaking them down into simpler problems.
• In this case, "Programming" = "Planning".
• It works on problems with Overlapping structure and optimal structure.
• Generating Fibonacci numbers
  • Recursive approach:

    • FIB_R(n)
      
       if n = 1  or  n = 2 then
           return 1
       else
           return FIB_R(n-1) + FIB_R(n-2)
      
      	

    • Time: T(n) = T(n-1)+T(n-2) +1
    • Um, this is hard, approximately O(1.6ⁿ)
    How about non recursive?
    • We could work the other way
      • Solve the sub problems and combine to a final solution

    • FIB_NR(n)
      
       A[1] ← 1
       A[2] ← 1
       for i ← 3 to n do
          A[i] ← A[i-1] + A[i-2]
       return A[n]
      
      	    

    • We probably don't need to store the values but that is dynamic programming.
    • (This isn't the best problem for dynamic programming but ...)
    • It is clearly O(n)
  • The coin row problem
    • There are n coins of different values in a row.
    • If you take a coin, you may not take a coin next to it.
      • If you take the coin at position k, you may not take the coins at positions k-1 or k+1
    • Your goal is to the the maximum value of coins.
    • You develop a formula F(n), that represents the solution to the problem for the first n coins.
    • F(0) = 0, F(1) = c₁
    • F(n) = max(F(n-1), F(n-2)+c_n) for n > 1
    • In the method, we compute the value of the function F(n) for all coins.

    • COIN_ROW(C[1..n])
      
       F[0] ← 0
       F[1] ← C[1]
       for i ← 2   to n  do
           F[i] ← max(F[i-2]+C[i],F[i-1])
       return F[n]
      
      	 

    • Trace this for C = { 5, 1, 2, 10, 6, 2}
    • Trace this for C = { 7,1,7,1,7,19,7,1}
    • What does F[n] represent?