Memoization For Beginners Image Memoization For Beginners

In this tutorial we are going to look at a concept in computer science called memoization. This is a really cool concept that allows us to optimize the runtime performance of some of our recursive algorithms by effectively caching the results of previous computations so that they don’t have to be continuously re-computed.

The Fibonacci Example

Calculating Fibonacci in a recursive manner is quite possibly the best example I’ve come across when it comes to showing the power of memoization.

Imagine we had a function that computed the fibonacci number n like so:

# Basic fibonacci function
# 1 + 1 + 2 + 3 + 5 + 8 + 13
def fib(n):
    if n <= 0:
        return 0
    if n == 1:
        return 1
    return fib(n-1) + fib(n-2)

When we then tried to run our fib(7) function it would then compute the following answer.

>>> import fibonacci
>>> fibonacci.fib(7)
13

Now the runtime complexity of this relatively simple function above would be O(2^n) which is incredibly inefficient as we start to compute larger and larger fibonacci numbers.

The Memoization Optimization

Through the use of memoization we could effectively store the results of previous computations. In order to store our results we will use a dict in Python.

def fib_with_memo(n, memo):
    if n <= 0:
        return 0
    if n == 1:
        return 1
    if n not in memo:
        print("Memo Computed")
        memo[n] = fib_with_memo(n-1, memo) + fib_with_memo(n-2, memo)

    return memo[n]

memo = {}

print(fib_with_memo(9, memo))
print(memo)

When you run this you should get the following output. As you can see from the number of times Memo Computed is printed out, we have been able to effectively optimize the number of times we have to recursively call fib().

 $ python3.6 fibonacci.py
Memo Computed
Memo Computed
Memo Computed
Memo Computed
Memo Computed
Memo Computed
Memo Computed
Memo Computed
34
{2: 1, 3: 2, 4: 3, 5: 5, 6: 8, 7: 13, 8: 21, 9: 34}

We have been able to modify our program and change is runtime performance from O(2^N) to O(N) which is a huge saving.

Entire Program

The entire Python file can be found below.

import time

def fib(n):
    if n <= 0:
        return 0
    if n == 1:
        return 1
    return fib(n-1) + fib(n-2)

def fib_with_memo(n, memo):
    if n <= 0:
        return 0
    if n == 1:
        return 1
    if n not in memo:
        memo[n] = fib_with_memo(n-1, memo) + fib_with_memo(n-2, memo)

    return memo[n]

memo = {}

start_time = time.time()
print(fib(35))
end_time = time.time()
print("Total Time: {}".format(end_time - start_time))

start_time = time.time()
print(fib_with_memo(35, memo))
end_time = time.time()
print("Total Time: {}".format(end_time - start_time))

print(memo)

The outputs of this are:

 $ python3.6 fibonacci.py
9227465
Total Time: 7.323758840560913
9227465
Total Time: 0.00010204315185546875
{2: 1, 3: 2, 4: 3, 5: 5, 6: 8, 7: 13, 8: 21, 9: 34, 10: 55, 11: 89, 12: 144, 13: 233, 14: 377, 15: 610, 16: 987, 17: 1597, 18: 2584, 19: 4181, 20: 6765, 21: 10946, 22: 17711, 23: 28657, 24: 46368, 25: 75025,26: 121393, 27: 196418, 28: 317811, 29: 514229, 30: 832040, 31: 1346269, 32: 2178309, 33: 3524578, 34: 5702887, 35: 9227465}

As you can see the memoized version of the fibonacci function returns in a fraction of the time.

Conclusion

If you found this tutorial useful or need further explanation then please feel free to let me know in the comments section below!

Elliot Forbes

Elliot Forbes
Twitter: @Elliot_f

Hey, I'm Elliot and I've been working on TutorialEdge for the last 4 years! If you have any tips or suggestions as to how I can make it better, please let me know in the suggestion box below!

Comments Section