Topics

• Recurrence
• Memoization
• Dynamic Programming
• Memoization VS Bottom-up DP

Recurrence

• A recurrence is a way to define a function on the (tuples of) nonnegative integers by giving two things:

  1. values of the function for a finite number of small base cases,
  2. values of the function for the rest of the cases in terms of values of the function on smaller arguments.

• Example: the Fibonacci numbers are defined as

  f(0) = 0,  f(1) = 1,  and f(n) = f(n-1) + f(n-2) if n > 1.

• As demonstrated in class, naively implementing the recurrence gives an inefficient algorithm because of repeated computation.

Memoization

• Memoization is a technique for writing efficient programs to solve a recurrence whose definition gives an inefficient algorithm if implemented top-down.

• Ideas of Memoization

  • Use a table to store previously computed values.

  • Initialize the whole table to UNKNOWN VALUE.

  • Each time a value is computed and known, immediately store it into the table.

  • Any time a value is needed, check first whether it is already stored in the table. If it is, use it; otherwise, compute its value.

  • To compute the value of the function on any argument, use the recurrence and the above two ideas.

Dynamic Programming

• Like memoization, dynamic programming is appropriate for solving a problem that can be described by a recurrence.

• Ideas of Dynamic Programming

  • Use a table to store computed values.

  • To solve a problem by dynamic programming, perform the following two steps.

    1. Fill in all entries of the table using the recurrence.
    2. Return the desired value from the table.

Memoization VS Bottom-up DP