# Dynamic Programming - Memoization

### Memoized Solutions - Overview

• Memoization is a technique for improving the performance of recursive algorithms
• It involves rewriting the recursive algorithm so that as answers to problems are found, they are stored in an array.

• Recursive calls can look up results in the array rather than having to recalculate them

• Memoization improves performance because partial results are never calculated twice

• Example: fibonacci

### Fibonacci - Simple Recursive Solution

• fibb(0) = 0, fibb(1) = 1; fibb(n) = fibb(n-1) + fibb(n-2)

• Obvious algorithm:
• Code (precondition: n ≥ 0):
•     fibb(n)
if n < 2
return n
else
return fibb(n-1) + fibb(n-2)

• Performance:
• Recurrence: $T(n) = ...$
• $T(n)$ is exponential
• Actually, $T(n) = \Theta(\text{fibb}(n)$
• $\text{fibb}(n) \simeq 1.6^n$

### Fibonacci: Iterative Bottom-Up Solution

• Compute a table of values of fibb(0) up to fibb(n)
•         fibb(n): -- Precond: n ≥ 0
A: Array(0..n) of Natural;
A(0) := 0;
if n > 0 then
A(1) := 1;
for i in 2 .. n loop
A(i) := A(i-1) + A(i-2);
end if;
return A(n)

• What is the performance?

• We figured out the optimum order to fill the array:
• Always had solutions to subproblems when we needed them

### Fibonacci: Memoized, Recursive Top-Down Solution

• A linear recursive algorithm - uses memoization
• Do recursion until reach base case, then fill array while returning:
•         fib(n):
A: Array(0..n) of Natural := (0=>0, 1=>1, others=>0);
return fib-aux(n, A)

fib-aux(n, A: in out array):
if A(n) = 0 and then n /= 0 then       -- Check if A(n) is calculated yet

A(n) := fib-aux(n-1, A) + A(n-2);  -- Store solution

end if;
end if
return A(n)                                -- Return solution

client:
put(fib(5));

• How many times is fib-aux called?
• This is a top down solution
• We arrange the recursion so that A(n-2) is calculated before it is needed
• This technique is called memoization

### Memoized Programs - Summary

• Memoized programs store results of smaller subproblems

• Results of smaller subproblems are used in solving larger problems

• No subproblem result is calculated twice

• Now: the Rod Cuttin Problem
Back to Dynamic Programming