# Dynamic Programming

## Solving Dynamic Problem Easy

Dynamic Programming (DP) is a technique that solves a few specific form of problems in Polynomial Time. Dynamic Programming solutions are quicker than the exponential brute method and can be effortlessly proved for their correctness. Before we take a look at the way to suppose Dynamically for a problem, we want to study:

Overlapping Subproblems
Optimal Substructure Property

Steps to clear up a DP
1) Identify if it’s miles a DP hassle
2) Decide a nation expression with
least parameters
3) Formulate state dating
four) Do tabulation (or add memoization)

## Step 1 : How to categorize a problem as a Dynamic Programming Problem?

Typically, all of the issues that require to maximize or reduce certain quantity or counting problems that say to matter the preparations underneath certain circumstance or positive chance troubles can be solved through the usage of Dynamic Programming.
All dynamic programming troubles satisfy the overlapping subproblems belongings and maximum of the traditional dynamic troubles also satisfy the most reliable substructure belongings. Once, we have a look at these residences in a given problem, be sure that it may be solved the use of DP.

## Step 2 : Deciding the kingdom

DP issues are all approximately kingdom and their transition. This is the most simple step which need to be performed very carefully because the state transition relies upon on the choice of country definition you make. So, permit’s see what can we suggest by the time period “country”.

State A nation can be defined as the set of parameters that can uniquely perceive a certain position or status within the given problem. This set of parameters should be as small as feasible to lessen state area.

For example: In our well-known Knapsack hassle, we define our country by using two parameters index and weight i.E DP[index][weight]. Here DP[index][weight] tells us the most income it can make with the aid of taking objects from variety 0 to index having the potential of sack to be weight. Therefore, here the parameters index and weight together can uniquely identify a subproblem for the knapsack problem.

So, our first step might be identifying a kingdom for the problem after figuring out that the trouble is a DP hassle.

As we recognize DP is all approximately the usage of calculated results to formulate the very last end result.
So, our next step can be to find a relation among previous states to attain the modern state.

## Step three : Formulating a relation most of the states

This part is the toughest a part of for solving a DP problem and requires quite a few instinct, remark and exercise. Let’s apprehend it by thinking about a sample trouble

Given three numbers 1, three, five, we want to inform
the entire variety of methods we will form a variety of ‘N’
the use of the sum of the given 3 numbers.
(allowing repetitions and extraordinary preparations).

Total variety of ways to form 6 is: 8
1+1+1+1+1+1
1+1+1+three
1+1+three+1
1+three+1+1
three+1+1+1
3+3
1+five
five+1

Let’s think dynamically about this problem. So, to begin with, we determine a country for the given trouble. We will take a parameter n to decide country as it can uniquely pick out any subproblem. So, our country dp will appear like nation(n). Here, country(n) manner the entire variety of arrangements to form n through the usage of 1, 3, five as elements.

#### Now, we want to compute state(n).

How to do it?
So right here the intuition comes into movement. As we are able to most effective use 1, 3 or 5 to form a given quantity. Let us expect that we recognize the end result for n = 1,2,3,4,five,6 ; being termilogistic let us say we understand the result for the
state (n = 1), nation (n = 2), state (n = three) ……… kingdom (n = 6)

Now, we want to recognise the end result of the state (n = 7). See, we can simplest add 1, three and 5. Now we can get a sum general of 7 by the following three approaches:

1) Adding 1 to all feasible mixtures of state (n = 6)
Eg : [ (1+1+1+1+1+1) + 1]
[ (1+1+1+3) + 1]
[ (1+1+3+1) + 1]
[ (1+3+1+1) + 1]
[ (3+1+1+1) + 1]
[ (3+3) + 1]
[ (1+5) + 1]
[ (5+1) + 1]

2) Adding three to all possible mixtures of kingdom (n = four);

Eg : [(1+1+1+1) + 3]
[(1+3) + 3]
[(3+1) + 3]

three) Adding five to all possible mixtures of kingdom(n = 2)
Eg : [ (1+1) + 5]

Now, assume carefully and fulfill your self that the above 3 instances are overlaying all feasible methods to form a sum overall of 7;

Therefore, we are able to say that end result for
country(7) = nation (6) + country (four) + nation (2)
or
country(7) = kingdom (7-1) + kingdom (7-three) + kingdom (7-5)

In standard,
nation(n) = kingdom(n-1) + nation(n-three) + state(n-5)

So, our code will look like:
filter_none

edit

play_arrow

brightness_4
// Returns the number of preparations to
// form ‘n’
int clear up(int n)

// base case
if (n < zero)
go back 0;
if (n == 0)
return 1;

go back remedy(n-1) + remedy(n-3) + resolve(n-five);

The above code appears exponential as it’s miles calculating the same kingdom time and again. So, we simply want to add a memoization.

## Step 4 : Adding memoization or tabulation for the state in Dynamic Problem

This is the easiest part of a dynamic programming solution. We simply need to shop the state solution so that subsequent time that state is needed, we can at once use it from our reminiscence

Adding memoization to the above code
// initialize to -1
int dp[MAXN];

// this function returns the wide variety of
// preparations to shape ‘n’
int remedy(int n)

// base case
if (n < 0)
return zero;
if (n == 0)
return 1; 