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

## Recursion = brute force

We saw some examples of recursion earlier in this chapter. One recurring theme (pun intended) in all those problems was high time complexity. Why was that the case? Because all those problems required a brute force search. We had to search in the whole solution space to look for an answer. For example, in the permutation challenge, we had to find all the possible combinations of characters. In the N queens problem, we had to look at all possible placements of queens until we found an optimal one. So, recursion in most cases is an excellent brute force technique. But as the name also suggests, it is not a very elegant one; thus, we will be learning about techniques that make recursion more efficient.




## Recursion's inefficiency visualized

Let’s rerun this Fibonacci numbers algorithm given in the start of this chapter. This time, we have plotted the time taken by each Fibonacci number to compute. Try different values by updating the value of variable `numbers`:



# Recursion = brute force

We saw some examples of recursion earlier in this chapter. One recurring theme (pun intended) in all those problems was high time complexity. Why was that the case? Because all those problems required a brute force search. We had to search in the whole solution space to look for an answer. For example, in the permutation challenge, we had to find all the possible combinations of characters. In the N queens problem, we had to look at all possible placements of queens until we found an optimal one. So, recursion in most cases is an excellent brute force technique. But as the name also suggests, it is not a very elegant one; thus, we will be learning about techniques that make recursion more efficient.




# Recursion's inefficiency visualized

Let’s rerun this Fibonacci numbers algorithm given in the start of this chapter. This time, we have plotted the time taken by each Fibonacci number to compute. Try different values by updating the value of variable `numbers`:



This lesson will argue for using dynamic programming instead of recursion to solve complex problems.

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

Is Plain Recursion Good Enough?

Recursion = brute force

Recursion’s inefficiency visualized