**Dynamic Programming Using Recursion**

In the field of computer science, dynamic programming is an extensively researched idea. It is more than just an algorithm, it’s an algorithmic technique for solving problems involving optimization and calculation.

Richard Bellman was the first to demonstrate dynamic programming. Many people consider DP as a method that is the combination of recursion and memoization. Let’s see if that actually explains what DP is from the aspect of using recursion.You can find more information at algo.monster.

Before we go any further, try figuring out what DP refers to at first.

**What is dynamic programming? (How does it work?)**

DP is an algorithm that offers optimization solutions in solving complex issues. How does it work? Well, basically, it decomposes the target issue into relatively easy sub-issues. The sub ones are simple enough and you can solve them directly. And to prevent from calculating the same issue again, it stores the results. To put it in another way, you split a problem into smaller ones, solving each one only once with the answers stores for later use. Then you constructed the final solution for the target issue. The ultimate solution is optimal in general.

Next, let’s see what that means when they say DP is memoization plus recursion.** **

**Memoization is a great solution (how it avoids repetition)**

What is it? Memoization is a tool that tracks and caches the results. If the same problem shows up again, you don’t need to calculate again. Because you can use the answers you have saved.

The programmer can deal with the situation when the dynamic programming problems are too complex for him to solve. In such a case he uses memoization. This technique reduces the workload considerably. Since a simple memoization algorithm is implemented in C/C++, a programmer can easily create and use a memoized function, even if his knowledge of dynamic programming is not perfect.

**What is recursion? (in a DP problem)**

What recursion applies is a top-down process, which is recalling itself.

Recursion may experience recalculation. But dynamic programming avoids this by adding memoization into this technology. Thus there’s no repetitive computation in the DP algorithm when solving a problem.

**Recursion in dynamic programming **

The main difference between ordinary and dynamic programming is that in the former, you write a single function written twice. That is: once inside the compiler, and once at runtime. For example, let us consider a program that produces a random number between 0 and 1. That function will be called twice inside the compiler – once inside the program and once at runtime. In a well-specified dynamic programming language, such functions are written recursively.

**Dynamic programming avoids repetition in a recursive calculating process**

Dynamic programming, sometimes called procedural programming, is about ordering your mathematical computations in such a manner that avoids calculating multiple times for the same sub-problem. More precisely, dynamic programming is a method that programmers use to prevent computing more than once the exact same sub-problem in an exponential algorithm.

This type of programming, when implemented well can reduce a programmer’s code to a finite set of instructions. This means that if you want to build a complex system, programmers may well only need to recursively call some methods once. Thus reducing programmers’ errors and improving efficiency.

**Dynamic programming and recursion in Fibonacci problems**

Recursion is the classic way of solving a problem in dynamic programming, where you take a function that solves one of the sub-problems. For example, to solve the so-called Fibonacci sub-problem, which deals with the squares of a number (i.e. the total number of sides of the rectangle, or the sum of the first two elements of a number, or the product of the first two sides of a square).

**Two methods of solving problems**

To solve the questions related to dynamic programming, you have two methods. The solution has to work both inside and outside the system, programmers often choose to use a hybrid technique, i.e. recursion or lazy evaluation.

Recursion works inside the computer by generating an output based on previous output, whereas lazy evaluation applies a function template to a series of inputs, and generates a single output when all of them are satisfied.

You can apply recursion to solve many other small problems as well, but we need a lot more input to make it efficient. Lazy evaluation will help solve these smaller sub-problems. To change the working code during a recursion, the programmer uses a template.

He uses this template to generate the required new code whenever it becomes necessary to solve a new sub-problem. During the execution of such a function, the changing parameters of the function can also be evaluated. And then programmers can use the resulting output for the purpose of generating the new function.

**Tips for programmers who use dynamic programming in Fibonacci**

For programmers, they can use dynamic programming Fibonacci to create a variety of problems, from simple numeric problems to scientific analysis. Dynamic programmers use a large variety of different techniques to write readable, compact programs.

However, programmers need to be very careful not to repeat the same functions unnecessarily, since such repeating functions can make the program rather boring. They should also make sure that they use a memory model which ensures that repeated calls for the same information are efficiently allocated and thus result in an improved performance level.

**Final thoughts and suggestions**

Programmers regard dynamic programming algorithm as one of the most important techniques of solving optimization-related problems. It is gaining popularity these days.

The number of people who try to study and master it is increasing. They start this algorithm for various reasons. Some of them are programmers. They learn it for self-improvement. Some others are trying for a coming job interview. No matter what the reason it is, hopefully, you’ve learned something from this article.

Well, for detailed and more accurate information about programming and computer science, I recommend you algo.monster. It offers programming courses for all sorts of learners: beginners or soon-to-be experts. Check it out to open a door for a brighter outlook!