Gain insights into dynamic programming, explore recursion basics, and delve into advanced techniques like Bottom-Up optimization. Discover ways to solve complex problems more efficiently with hands-on coding challenges.

Dynamic programming is something every developer should have in their toolkit. It allows you to optimize your algorithm with respect to time and space — a very important concept in real-world applications.

In this course, you’ll start by learning the basics of recursion and work your way to more advanced DP concepts like Bottom-Up optimization. Throughout this course, you will learn various types of DP techniques for solving even the most complex problems. Each section is complete with coding challenges of varying difficulty so you can practice a wide range of problems.

By the time you’ve completed this course, you will be able to utilize dynamic programming in your own projects.

Dynamic Programming in Python: Optimizing Programs for Efficiency

# Optimizing Fibonacci number's algorithm

Let's revisit the Fibonacci numbers algorithm from an [earlier lesson](https://www.educative.io/courses/dynamic-programming-in-python/the-fibonacci-numbers) of this course. 

def fib(n):
  if n == 0: # base case 1
    return 0
  if n == 1: # base case 2
    return 1
  else: # recursive step
    return fib(n-1) + fib(n-2)

print (fib(10))

We have also reproduced a dry run of `Fib(6)` below to visualize how this algorithm runs.

# Memoization

Now let’s store the results of every evaluated Fibonacci number and reuse it whenever it is needed again. We can use either a list or dictionary for memoization in this problem. In this course, we will use a dictionary because it is more convenient than a list. The only changes we are going to make to our original Fibonacci algorithm is the addition and usage of this new dictionary. We have defined a dictionary globally so it is available to all the `fib()` calls (*line 1*). Next, after the base cases, we check whether this number has already been evaluated, if it was, its memoized value is returned (*lines 8-9*). Otherwise, we need to evaluate this result, and this is where we make the recursive call (*lines 11-12*). Here before returning, we memoize the result in `memo[n]`. We do not need to memoize base cases as they are already usually *O(1)* operations.




In this lesson, we will employ memoization in the Fibonacci numbers algorithm.

Chapter 1: From Recursion to Dynamic Programming

Chapter 2: Top-Down Dynamic Programming with Memoization

Chapter 3: Bottom-Up Dynamic Programming with Tabulation

Chapter 4: Practice Problems

The Fibonacci Numbers Algorithm with Memoization

Optimizing Fibonacci number’s algorithm

Memoization