Disclaimer: This post may contain affiliate links, meaning we get a small commission if you make a purchase through our links, at no cost to you. For more information, please visit our Disclaimer Page.

Dynamic programming and recursion have been used in programming languages for a while. Both are optimization methods that can be easily confused with each other: however, they are not the same and have a big difference.

Dynamic programming is an optimization method used for problem-solving; the problems are broken into smaller subproblems to be solved. While recursion is when a function can be called and executed by itself.


Both methods have different uses, but recursion can be used in dynamic programming, even when this can perfectly function without this.

What Is Dynamic Programming?

Dynamic programming is a large class of algorithms that are used for problem-solving optimization. Dynamic programming is methods and techniques that numerically analyze probabilities to solve a problem, and then solve the named problem.

In 1905s, Richard Bellman introduced dynamic programming for mathematical optimization; furthermore, this has been developed and used in several fields for problem-solving. The basis for these techniques is to solve problems by resolving simpler sub-problems headed to finally solve the complex one. They simplified the whole scene by looking for the optimal solutions for the sub-problems, so the final solution will be easier to elucidate.

In dynamic programming, many different sets of algorithms are stored to solve each simple sub-problem. This works under the concept that smaller problems end in a complex one, so, once the sub-problems are corrected, the final scene is solved. Thus, the use of these techniques reduces errors, ensures efficacy in the linework, and improves the quality of the final result.

How Does Dynamic Programming Work?

Dynamic programming is an optimization technique to solve sub-problems to break down a final complex problem. This is based on the fact that smaller problems constituted a bigger one, so once the sub-problems are solved the whole scene clarifies. So, to generalize, dynamic programming works by recognizing a sub-problem, solving it, and storing the solutions; thus, if the problem occurs again, there is no need to recompute the solution.

Though there are different sets of algorithms to solve different sub-problems, and yet there is a pattern in the way most of them work. This process can be summarized in six simple steps; however, some sub-problems are more complex than others, and according to the field, they may change.

However, here is a brief explanation of each step, and what is done in all of them:

Recognition of the problem and its variables

When the whole scene looks complex, it is time to look for the smaller problems. This is hard to do, though the problem gives a hint about what sub-problems could be. To do this, the state needs to be determined.

The states are the parameters that help to identify a specific position in the problem. These parameters facilitate recognizing the problems and their variables, and as a result, the sub-problems.

Formulate the relation between the variables

So, once the state is set, and the variables are determined, it is time to express the current relationship between the variables. This will help to clarify the problem and have a better understanding of it.

To do this, the programmer has to add all the combinations for a specific state, thus the result of them having to be the same. As a consequence, the variables have a mathematical relation, and now, the current relation between this has been formulated.

Look for the base cases

Sometimes, some sub-problems do not depend nor correlate with other sub-problems. This happens when the parameters are no longer applicable for a sub-problem, then listing assertions that will explain the given sub-problem.

Add Memoization

This is the last step of dynamic programming, here the results and solutions for each sub-problem are stored, and every time one of these occurs, they will be automatically solved, and the programmer doesn’t need to recompute the solutions.

Memoization is an optimization technique where results of functions are stored to improve the performance of programs and problem-solving. This technique is made to call the stored functions that rewrite the recursive algorithms to solve the sub-problems. As well, these functions can be programmed to call and then be executed by themselves, if it is needed.


What Is Recursion?

The recursive process occurs when one function calls itself; this one receives the name of the recursive function. Recursion techniques are widely used to optimize the process of large operations that involve complex algorithms.

A recursive function is a routine, where an algorithm is called –by itself– to solve problems more efficiently and, somehow, automatically. Based on the fact that when a problem is discovered and then solved, setting a recursive function will avoid repeating the whole process and recomputing everything again. I can say that a recursive function works in a loop: the software recognizes an error, the function is called, and then the problem is resolved.

How Does Recursion Work?

Recursive methods allow programmers to create more efficient programs. In simple words, recursion is basically when a function calls itself to execute a specific command, though it is a little bit more complex than that because when the named function is not formulated correctly, it would work in an infinite loop and the whole software will malfunction and it won’t run properly.

So, to understand how recursion works, it is important to clarify some terms that by themselves explain how the recursion works.

Recursive Function

I have already explained that recursive methods are a function that calls itself to be executed, the named function receives the name of the recursive function. For a recursive function to work properly, this has to be programmed to be recognized by itself when it needs it, and when to stop.

A recursive function is an algorithm that works –in general terms– in three phases: recognize when it is needed, execute itself, and then stop working. So, to complete these phases, the recursive function has to determine the base case and the recursive case.

Recursive Case or Structure. Once when it is identified the moment that the function is needed, the function calls itself and it is executed; this process is known as a recursive case, just so simple like that. Now, the “complexity” behind the recursive case is to program the moment when the function called itself; then this is executed and accurately resolved the sub-problem.

Base Case or Condition. In simple words, it could be said that it is the termination point of the function. When the function has been successfully executed, this needs to be stopped, otherwise, the function will keep calling and executing itself in a loop, and here is where the base case or condition takes its place. The function is executed perfectly, so this solves the problem and returns a result, then the function is finished.

Direct and Indirect Recursion

This is another important situation to take into consideration when it comes to recursion. While recursion always refers to when a function calls itself, this can vary in the way it is called, so two types of recursion are established: direct and indirect recursion.

Direct Recursion. When the function calls directly itself, and the function is independent to do it, this is a direct recursion.

Indirect Recursion. When a function depends on another function (mutual function call) to call itself, it receives the name of indirect recursion.

Tail Recursive Method and Infinite Recursion

Once a recursive function is successfully executed, what happens next? Well, two options can happen.

Tail Recursive Method. A series of functions are executed, but the final statement is a recursive function, then a whole task is finished; this is a recursive method.

Infinite Recursion. When a recursive function results in another recursive function, it is named infinite recursion; though this doesn’t have to be confused as an error. Every recursive function has to be successfully completed and finished, otherwise will start again with the same function, and not in other recursive functions.

What Is the Difference Between Dynamic Programming and Recursion?

Recursion is when a function can be called and executed by itself, while dynamic programming is the process of solving problems by breaking them down into sub-problems to resolve the complex one. Dynamic programming can function without using recursion techniques, though, since dynamic programming is an optimization of solving problems, programmers tend to use recursion to accelerate and optimize the process.

When a function can call itself to execute a specific task, receive the name of the recursive function. This function is recognized by itself when it has to be executed, so it calls itself to perform and accomplish the work.

Dynamic programming is a set of algorithms made to solve a problem by breaking it into smaller ones, named sub-problems. In dynamic programming, the programmer solves the first time the problem, then as a final step, it applies memoization to store these solutions.

So, the main difference would be the use that is given to each technique, recursion is to automate a function, any kind of function; while dynamic programming is an optimization technique made to solve problems.

A recursive function is an algorithm that recognizes when it is needed, it can be executed itself, and then stop working. So, when the function identifies the moment that it is needed, then it proceeds to call itself and it is executed; this part of the process is known as a recursive case. Consequently, the function needs to stop once the task is completed, this termination point is known as the base case or condition.

Dynamic programming establishes parameters known as states that help to recognize the problem and divide it into sub-problems to solve the whole scene. These sub-problems, also known as variables, are solved and then the programmer has to formulate a mathematical relation between these. Finally, these solutions and results are stored as algorithms, so these can be applied whenever it is needed without solving the whole problem step by step.


Is Dynamic Programming Just Recursion?

Dynamic programming and recursion are things completely different. While dynamic programming can use recursion techniques, recursion itself doesn’t have anything similar to dynamic programming.

Dynamic programming can be defined as a set of algorithms that are used to solve a big and complex problem by breaking it into smaller ones; these smaller problems receive the name of sub-problems. When dynamic programming is used, a programmer resolves the first time the problem, then as a final step, it applies memoization that is when the solution and the results are stored –in form of algorithms– so when the problem appears again, this doesn’t have to be solved step by step.

The programmer has to establish parameters known as states that help to recognize the problem and break it into sub-problems to solve the first one. The sub-problems are variables that the programmer solves and formulates a mathematical relation between these. Finally, these solutions and results are stored as algorithms to be used when they are required instead of having to recompute the whole problem again.

Recursion is when a function can be called and to be executed itself, then stop working. The recursive function identifies when it is needed, this calls itself and it is executed. Therefore, the function proceeds to stop once the task is completed, this is a termination point for the recursive function. A statement can be ended with a recursive function or can keep calling another recursive function

Dynamic programming can use recursion to automate the process of solving problems, however, this can work perfectly without it.


Dynamic programming and recursion are two optimization methods used to improve the performance of software but these don’t have to be confused. They are functional and when they are properly applied the programs will run perfectly.