What is the Basis of Dynamic Programming and What Needs to be Known About It?

Dynamic Programming problems optimal solutions by breaking them into smaller parts by dividing by interpreting them from top to bottom or bottom to top, saving previous solutions and comparing them with the next ones, it is a programming approach aimed at finding efficient solutions where each sub-solution is solved only once. Bottom-up and Top-down approaches can be interpreted as two methods. In this solution, which begins by finding a brute force iterative solution, we attempt to find the most efficient solution using Dynamic Programming.

2. About Dynamic Programming Methods

Dynamic programming interpretation where the solutions of small problem parts are known and interpreted to simplify the solution is called memoization. Memoization is a top-down approach. The method where the small parts of the solution are interpreted through tables and examined using a bottom-up approach is called tabulation. These allow us to apply various interpretations to different types of questions and significantly simplify our work.

3. How is a Dynamic Approach Created?

To establish Dynamic Programming, we need a few steps. They can be summarized as follows: 

• As we can infer from the basic principle of Dynamic Programming, we first break into small parts.

• Analyze the solutions on sub-problems to prepare the decisions that need to be made at each step

• Analyze your main problem by repeating the upper steps, meaning you have one where you have broken it into small parts and another where you have the data interpreted in a mathematical form for your decision mechanism. With this data, ponder the question of how to solve the main problem.

• memoization or tabulation. Focus on them

• Work on translating all this data into code

Dynamic Programming, which can be established in this way, can vary in questions, approaches, and cases based on this roadmap. I will try to explain known Dynamic Programming examples in the next topic.

4. Known Dynamic Programming Solutions 

Let's start with a topic where an optimal solution is obtained using Dynamic Programming and then the solution is formalized; 

Matrix Chain Multiplication calculations. In a given matrix chain multiplication, we need to calculate where to place parentheses, i.e., where to prioritize operations. We can easily reach its solution using Dynamic Programming. Mathematically, square matrices can be multiplied in pairs, and incorrect operation precedence can lead to many more computational steps, thus significantly slowing down the system. By filling tables, we can easily reach the optimal solution using Dynamic Programming by parenthesizing in this way. In the repetitive solution, checking appropriate and inappropriate conditions will be sufficient for us. It is also useful to think a bit about memoization. In Dynamic Programming, which is originally a bottom-up approach, memoization solutions are usually more efficient in points where a top-down strategy is required. Our second solution example finding the longest similar subsequence is what you might be hearing. Think of two arrays consisting of letters, and we are asked to find the longest series of similar elements between these two arrays. Additionally, we needed an efficient solution, in which case Dynamic Programming will be beneficial to us. With the table we hold in Dynamic Programming, we can find the longest series using our general solution approach. Our general solution approach for Dynamic Programming is as follows;

0 invalid cases

C[i,j]= C[i-1,j-1] cannot handle

C[i,W]= C[i-1,W] if the item's weight exceeds the remaining weight capacity of my bag.

Max(Vi + C[i-1,W-Wi], C[i-1,W]) decision

Thus, the value 0 is set for invalid cases, meaning when the item is 0 or the weight is 0. In situations where the item's weight exceeds the remaining weight limit in the bag, the value should continue from the previous value in the array. For the decision part, if the current item fits within the remaining weight limit of your bag, but it's questionable whether taking it makes sense, the value of the item (Vi) is added to its value and compared, thus calculating the situation with the maximum value.

We can integrate this approach into our question, for example, for string similarity,

0 invalid cases

C[i-1,W] is returned. In the decision part, if the current item fits within the remaining weight limit of your bag, but it's questionable whether taking it makes sense, the value of the item (Vi) is added to its value and compared, thus calculating the situation with the maximum value.

0 value is set for invalid cases, meaning when the item is 0 or the weight is 0. In situations where the item's weight exceeds the remaining weight limit in the bag, the value should continue from the previous value in the array. For the decision part, if the current item fits within the remaining weight limit of your bag, but it's questionable whether taking it makes sense, the value of the item (Vi) is added to its value and compared, thus calculating the situation with the maximum value.

We can integrate this approach into our question, for example, for string similarity,

0 invalid cases

C[i-1,W] is returned. In the decision part, if the current item fits within the remaining weight limit of your bag, but it's questionable whether taking it makes sense, the value of the item (Vi) is added to its value and compared, thus calculating the situation with the maximum value.

Thus, Dynamic Programming with a memoized solution interpretation allows us to calculate our Fibonacci series with a single if-else structure. Therefore, our solution complexity analysis becomes,

C[i,W]= C[i-1,W] if the item's weight exceeds the remaining weight capacity of my bag.

Max(Vi + C[i-1,W-Wi], C[i-1,W]) decision 

Thus, our table is created where vertical elements hold one list and horizontal elements hold another list, which are compared to form the table.

And of course, we cannot omit the famous Knapsack problem. This problem is modeled to determine which items to select from the available options in the middle of our bag with a certain capacity to create the most valuable load. Objects have certain values and volumes, which will occupy space in our bag but will provide us with value. There are two types of this question model: one where we cannot break the objects, i.e., the type that can be solved with Dynamic Programming represented by 0-1 (binary), and the type where we can break the objects and partially account for them, which can be solved with the Greedy Approach. To interpret the 0-1 case, 0 represents not taking an item, and 1 represents taking it. For this, the Dynamic Programming solution can be described as follows:

C[i,W]= C[i-1,W] if the item's weight exceeds the remaining weight capacity of my bag.

Max(Vi + C[i-1,W-Wi], C[i-1,W]) decision 

Thus, our table is created where vertical elements hold one list and horizontal elements hold another list, which are compared to form the table.

And of course, we cannot omit the famous Knapsack problem. This problem is modeled to determine which items to select from the available options in the middle of our bag with a certain capacity to create the most valuable load. Objects have certain values and volumes, which will occupy space in our bag but will provide us with value. There are two types of this question model: one where we cannot break the objects, i.e., the type that can be solved with Dynamic Programming represented by 0-1 (binary), and the type where we can break the objects and partially account for them, which can be solved with the Greedy Approach. To interpret the 0-1 case, 0 represents not taking an item, and 1 represents taking it. For this, the Dynamic Programming solution can be described as follows:

C[i,W]= C[i-1,W] if the item's weight exceeds the remaining weight capacity of my bag.

Max(Vi + C[i-1,W-Wi], C[i-1,W]) decision 

Thus, our table is created where vertical elements hold one list and horizontal elements hold another list, which are compared to form the table.

And of course, we cannot omit the famous Knapsack problem. This problem is modeled to determine which items to select from the available options in the middle of our bag with a certain capacity to create the most valuable load. Objects have certain values and volumes, which will occupy space in our bag but will provide us with value. There are two types of this question model: one where we cannot break the objects, i.e., the type that can be solved with Dynamic Programming represented by 0-1 (binary), and the type where we can break the objects and partially account for them, which can be solved with the Greedy Approach. To interpret the 0-1 case, 0 represents not taking an item, and 1 represents taking it. For this, the Dynamic Programming solution can be described as follows:

C[i,W]= C[i-1,W] if the item's weight exceeds the remaining weight capacity of my bag.

Max(Vi + C[i-1,W-Wi], C[i-1,W]) decision 

Thus, the value 0 is set for invalid cases, meaning when the item is 0 or the weight is 0. In situations where the item's weight exceeds the remaining weight limit in the bag, the value should continue from the previous value in the array. For the decision part, if the current item fits within the remaining weight limit of your bag, but it's questionable whether taking it makes sense, the value of the item (Vi) is added to its value and compared, thus calculating the situation with the maximum value.

We can integrate this approach into our question, for example, for string similarity,

0 invalid cases

Visual example representing the Knapsack problem.

Thus, to summarize, Divide and Conquer works more on sub-problems, thus consuming more time, and the sub-problem solutions are independent of each other. On the contrary, in Dynamic Programming, sub-problems are dependent on each other and are solved only once, then recorded in a table and used in the solution, thereby increasing efficiency.

Dynamic Programming with memoized solution interpretation allows us to calculate our Fibonacci series with a single if-else structure. Therefore, our solution complexity analysis becomes,

C[i,W]= C[i-1,W] if the item's weight exceeds the remaining weight capacity of my bag.

Max(Vi + C[i-1,W-Wi], C[i-1,W]) otherwise, to compare their returns 

C[i-1,W] is returned. In the decision part, if the current item fits within the remaining weight limit of your bag, but it's questionable whether taking it makes sense, the value of the item (Vi) is added to its value and compared, thus calculating the situation with the maximum value.

C[i-1,W] is returned. In the decision part, if the current item fits within the remaining weight limit of your bag, but it's questionable whether taking it makes sense, the value of the item (Vi) is added to its value and compared, thus calculating the situation with the maximum value.

Therefore, in Divide and Conquer, the general complexity analysis is

T(n) = 2T(n-k) + O(1) and O(n) represents the conquer process, which is the time to solve the problem within itself.

C[i,W]= C[i-1,W] if the item's weight exceeds the remaining weight capacity of my bag.

Max(Vi + C[i-1,W-Wi], C[i-1,W]) decision 

Thus, our table is created where vertical elements hold one list and horizontal elements hold another list, which are compared to form the table.

And of course, we cannot omit the famous Knapsack problem. This problem is modeled to determine which items to select from the available options in the middle of our bag with a certain capacity to create the most valuable load. Objects have certain values and volumes, which will occupy space in our bag but will provide us with value. There are two types of this question model: one where we cannot break the objects, i.e., the type that can be solved with Dynamic Programming represented by 0-1 (binary), and the type where we can break the objects and partially account for them, which can be solved with the Greedy Approach. To interpret the 0-1 case, 0 represents not taking an item, and 1 represents taking it. For this, the Dynamic Programming solution can be described as follows: