# {{ MonaCodeLisa }} # What is Dynamic Programming - Simple & Code Examples

In this blog post, I will cover the basics of dynamic programming, a technique for solving optimization problems. I'll discuss what dynamic programming is, how it works, and when it's most useful. I'll also provide examples of dynamic programming in action, using both TypeScript and Python, and compare them to other problem-solving techniques. Additionally, I'll address common misconceptions about dynamic programming and offer tips for implementing it effectively. By the end of this post, you'll have a solid understanding of dynamic programming and be ready to apply it to your own projects.

## What is Dynamic Programming

Dynamic programming is a method for solving complex problems by breaking them down into smaller, simpler subproblems and solving each subproblem only once. It is particularly useful for problems that have overlapping subproblems, as it can avoid redundant calculations and improve efficiency.

The basic idea of dynamic programming is to store the results of solving each subproblem in a table so that they can be looked up later when needed. This way, we can avoid solving the same subproblem multiple times, which can be very time-consuming.

Dynamic programming is commonly used in computer science and optimization problems, such as finding the shortest path in a graph, optimizing a sequence of decisions, or solving a knapsack problem. It is also used in many other fields, such as biology, economics, and physics, to model and solve complex problems.

## Is it a Programming Paradigm

Dynamic programming is not a programming paradigm in the sense of object-oriented programming, procedural programming, or functional programming. It is a problem-solving technique that can be used in any programming paradigm.

In dynamic programming, we break down a complex problem into smaller subproblems and solve each subproblem only once, storing the solutions in a table for later use. This approach can be applied in any programming language or paradigm, as long as the language supports data structures like arrays or hash tables for storing the solutions to subproblems.

So, while dynamic programming is not a programming paradigm, it is a useful problem-solving technique that can be used in conjunction with any programming paradigm.

## When is Dynamic Programming most useful

Dynamic programming is a powerful technique that is useful in a wide range of problem domains. Here are some cases and circumstances in which dynamic programming can be particularly useful:

1. Optimization problems: Dynamic programming is particularly well-suited for solving optimization problems, where the goal is to find the optimal solution among a large number of possible solutions. This includes problems such as finding the shortest path in a graph, maximizing profit in a business scenario, or minimizing the cost of a manufacturing process.

2. Problems with overlapping subproblems: Dynamic programming is most effective when a problem can be broken down into smaller subproblems that overlap with each other. By solving each subproblem only once and storing the solutions in a table or cache, dynamic programming can avoid redundant calculations and improve the efficiency of the solution.

3. Recursive problems: Many problems can be expressed recursively, with each instance of the problem depending on the solutions to smaller instances of the problem. Dynamic programming can be used to solve these recursive problems by breaking them down into subproblems and solving them iteratively.

4. Problems with optimal substructure: Dynamic programming is most effective when a problem has an optimal substructure, meaning that the optimal solution to the problem can be constructed from the optimal solutions to its subproblems. This property allows dynamic programming to find the global optimum by combining the solutions to the subproblems.

5. Problems with deterministic and discrete choices: Dynamic programming is most effective when a problem involves deterministic and discrete choices. In other words, when each decision has a clear outcome, and the decision space is finite and discrete. This includes problems such as the knapsack problem, where a set of items must be selected to maximize value while staying within a weight limit.

Overall, dynamic programming is particularly effective when the problem involves deterministic and discrete choices and can be solved iteratively using a table or cache.

## Code Examples

### TypeScript Example:

Suppose we want to calculate the nth Fibonacci number, where Fibonacci sequence is defined as the sum of the two preceding ones, starting from 0 and 1. We can use dynamic programming to improve the time complexity of the naive recursive solution, which has an exponential time complexity.

``````function fibonacci(n: number, memo: number[] = []): number {
// If the result for the current n has already been computed, return the result from the memo array
if (memo[n] !== undefined) {
return memo[n];
}

// Base cases
if (n <= 1) {
return n;
}

// Recursive case
const result = fibonacci(n - 1, memo) + fibonacci(n - 2, memo);
memo[n] = result;
return result;
}

// Example usage
console.log(fibonacci(10)); // Output: 55
``````

The `fibonacci` function takes two arguments: `n`, which is the index of the Fibonacci number to compute, and `memo`, which is an optional array that stores previously computed results.

The function uses memoization to improve performance by avoiding duplicate calculations. If the result for the current `n` has already been computed, the function returns the result from the `memo` array.

The function then checks if `n` is a base case (0 or 1) and returns the value of `n` if it is.

If `n` is not a base case, the function computes the Fibonacci number recursively by calling itself with `n-1` and `n-2`. It then adds these two results together to get the value for `n`.

The result for `n` is then stored in the `memo` array so that it can be retrieved later if needed. The function returns the result for `n`.

In the example usage, the `fibonacci` function is called with an argument of `10`. The function computes the 10th Fibonacci number (which is 55) and logs the result to the console.

### Python Example:

Suppose we want to find the length of the longest common subsequence (LCS) of two strings `s1` and `s2`. The LCS of two strings is the longest subsequence that is present in both strings. We can use dynamic programming to improve the time complexity of the naive recursive solution, which has an exponential time complexity.

``````def lcs(s1: str, s2: str) -> int:
# get the lengths of s1 and s2
m, n = len(s1), len(s2)

# create a 2D array dp with m+1 rows and n+1 columns, initialized to 0
dp = [ * (n + 1) for _ in range(m + 1)]

# iterate over each character of s1 and s2
for i in range(1, m + 1):
for j in range(1, n + 1):
# if the characters at the current positions of s1 and s2 are equal,
# set dp[i][j] to dp[i-1][j-1] + 1, which means that the length of the LCS increases by 1
if s1[i - 1] == s2[j - 1]:
dp[i][j] = dp[i - 1][j - 1] + 1
# if the characters at the current positions of s1 and s2 are not equal,
# set dp[i][j] to the maximum value of dp[i-1][j] and dp[i][j-1],
# which means that the LCS remains the same as the previous iteration
else:
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])

# return the final value of dp[m][n], which represents the length of the LCS between s1 and s2
return dp[m][n]
``````

The function takes two strings `s1` and `s2` as input and returns an integer representing the length of the longest common subsequence between the two strings.

The function uses a 2D array `dp` to keep track of the LCS at each position in the two strings. The LCS is computed using dynamic programming by breaking the problem down into subproblems and storing the solutions to these subproblems in `dp`.

The function iterates over each character of `s1` and `s2` and computes the length of the LCS at each position by comparing the characters at that position. If the characters are equal, the length of the LCS is incremented by 1, otherwise, the LCS remains the same as the previous iteration.

The final value of `dp[m][n]` represents the length of the longest common subsequence between `s1` and `s2`.

## Misconceptions about Dynamic Programming and Tips for implementing it effectively

One common misconception about dynamic programming is that it is always the best solution for optimization problems. While dynamic programming can be a powerful technique for solving many types of optimization problems, it is not always the most efficient or effective approach. For some problems, other techniques such as greedy algorithms or divide-and-conquer may be more suitable.

When implementing dynamic programming, it's important to pay attention to the details of the problem and choose the right data structures and algorithms to minimize computational overhead. It's also essential to ensure that the subproblems being solved are actually independent and have overlapping substructures.

Another tip for implementing dynamic programming effectively is to use memoization to store solutions to subproblems in a cache or table. Memoization can dramatically reduce the computational complexity of a problem by avoiding redundant calculations. Finally, it's important to test your dynamic programming solution thoroughly and verify that it produces the expected results. With these tips in mind, you can successfully apply dynamic programming to solve a wide range of optimization problems.

## Dynamic Programming vs Reactive Programming

Dynamic programming is a technique for solving optimization problems by breaking them down into smaller subproblems and solving each subproblem only once. The solutions to the subproblems are stored in a table or cache so that they can be looked up later when needed, which can save time by avoiding redundant calculations. Dynamic programming is often used in computer science and optimization problems, such as finding the shortest path in a graph or solving a knapsack problem.

Reactive programming, on the other hand, is a programming paradigm that is focused on asynchronous data streams and the propagation of changes through a system. In reactive programming, data is represented as a stream of events, and programs react to changes in the stream by applying functions to the data. Reactive programming is often used in event-driven systems, such as user interfaces or sensor networks.

To summarize - dynamic programming is a problem-solving technique used in optimization problems, while reactive programming is a programming paradigm used in event-driven systems. While the two concepts share the word "programming" in their names, they are not directly related and serve different purposes.

## Dynamic Programming: A Technique for Mid-Level Developers

Dynamic programming is typically not expected of junior developers, as it is a more advanced concept that requires a solid understanding of algorithms and data structures. In fact, if a developer is working with dynamic programming, it is a good indicator that they are not a junior developer.

Expecting someone to work with dynamic programming and referring to them as a junior developer would be unfair, as dynamic programming is often used in more complex projects that require a higher level of experience and expertise.

Dynamic programming is often used in projects related to artificial intelligence, machine learning, optimization, or data analysis. In these cases, mid-level or senior developers may be expected to have a good understanding of dynamic programming in order to solve problems efficiently.

For junior developers, it is important to have a strong foundation in computer science and algorithms, but they may not need to have a deep understanding of dynamic programming unless they are working on a project that specifically requires it. As they gain more experience and work on more complex projects, they can gradually build their knowledge and skills in dynamic programming and other advanced concepts.