Dynamic

Programming

It's just a fancy way of saying

“Remember stuff now, to save time later.”
Problem Statement
To understand dynamic programming in the simplest
terms, consider the following example.

What is ?
2+2+2+2=? 2 2 2 2

Now, What is ?
2+2+2+2+2=? 2 2 2 2

8 2
We can arrive at the answer
super quickly -

10
As we already know the answer
to the previous question and by
just adding another 2,

We can say the answer is 10!

Explanation

This can be represented by a question of the format,

what is the sum of 2 taken n times .

To solve this we can consider an array f, where f[n]

represents the sum of 2 taken n times, that is 2* n.

Mathematically, since we know that multiplication is

repeated addition, the sum of 2 taken n times will

always be equal to the sum of 2 taken n-1 times and 2

itself.

That is f(n)=f(n-1)+2

is a resultant recurrence relation for this problem

So if we have say n=4,

sum of 2 taken 3 times is 2+2+2=6

f(n-1)=f(3)=6

And f(4)=f(3)+2=6+2=8
To solve this question through code, we have to first

initialise the base cases or values of f(n) for small

values of n.

f(0)=0

( sum of 2 taken 0 times is zero)

f(1)=2

(sum of 2 taken 1 time is two)

int count2(int n)

//creating an array to store the previous values

int f[n+1];

//initialise the base cases

f[0]=0;

f[1]=2;

//iterate through 2 to n

for(int i=2;i<=n;i++)

f[i]=f[i-1]+2;

return f[n];

}
Complexity Analysis:

Time Complexity: O(n).

The array is traversed completely until n. So Time

Complexity is O(n).

Space Complexity: O(n).

To store the values in the f array, ‘n’ extra space is

needed.
Dynamic programming vs Recursion

The basic concepts of dynamic programming are

similar to recursion. You first calculate the answers to
the different sub-problems and then combine it to get
the final answer.

Dynamic programming trades space for time.It uses

more space to store the results of sub-problems to
reduce time taken rather than taking a lot of time to
calculate sub-problem solutions and saving space.

For Example

Consider the problem of finding out the nth Fibonacci

number.

A fibonacci series is defined as a series of numbers,

where each number is the sum of the previous two
numbers.

So if we start of with 0 and 1, the next number in the

series would be 1, since 0+1=1

Similarly the next number would 1+1=2

What is ? Now, what is ?

0+1=? 0 1 0 + 1 +1 = ?

0 1
1

1 1

0,1,1,2,3,5,8……

In general we get a recurrence relation as

fib(n) = fib(n-1) + fib(n-2)

To calculate the nth number of Fibonacci series, we

can either use a recursive approach or dynamic
programming approach.

int fib(int n)

if (n <= 1)
Recursion :

return n;
Exponential
return fib(n-l) + fib(n-2) ;

f[0] = 0;

f[1] = 1;

Dynamic
for (1 = 2; 1 <= n; i++)
Programming :

{
Linear
f[i] = f[i-1] + f[i-2];

return f(n];
If we use the recursive approach, it would take
exponential time for large values of n.

By using dynamic programming, the time complexity

reduces to linear, as the data is stored in an array.

Computation time is reduced as you simply need to

access previously calculated values to generate the nth
fibonacci number.

During recursion, sometimes solutions to subproblems

may be calculated many times.

Consider the same example of calculating the nth

fibonacci number

fib(n) = fib(n-1) + fib(n-2

fib(n-1) = fib(n-2) + fib(n-3

fib(n-2) = fib(n-3) + fib(n-4)

Here for different values of n, fib(n-3) is calculated

multiple times.

In dynamic programming, by storing the result of

fib[n-3] in an array, it can be accessed easily.

So in the dynamic programming approach we

calculate the value of each element in the fib array
only once and that value is used for the subsequent
calculations.

Dynamic programming works when a problem has

the following characteristics
Optimal Substructure: If an optimal solution
contains optimal subsolutions, then a problem
exhibits optimal substructure
Overlapping subproblems: When a recursive
algorithm visits the same subproblems repeatedly,
then a problem has overlapping subproblems.

In Divide and In Dynamic

Conquer Programming,,
Programming
technique the the subproblems
subproblems are are dependent
independent of on each other
each other. and they overlap.

There are two different methods to store pre

calculated values to save time.

Tabulation

In this method we follow a bottom up approach.

If you want to calculate the factorial of a given number

(n)!, you can store the previous products (n-1)! and just

multiply it with n.

The relation can be expressed as f[n]=f[n-1]*(n)

Here you first calculate the values of f[0], f[1], f[2]..... And

then calculate the value of f[n], that is the lower or

bottom values are calculated first and then higher

values are derived from them.

int f[MAXN];

int f[0] = 1; //base value

for (int i = 1; i< =n; i++)

f[i] = f[i-1] * i;

//sequentially updating the table - tabulation

Memoization
Memoization is a form of caching and is used to
optimise recursion.

It remembers the result of a function call with

particular inputs in a lookup table (generally referred
to as the "memo") and returns that result when the
function is called again with the same inputs.

Pseudocode for memoization method to calculate

factorial:

If n== 0,

return 1

Else if n is in the memo

return the memo's value for n

Else

Calculate (n−1)!×n

Store result in the memo

Return result

Algorithm
Dynamic Programming algorithm is designed using
the following four steps

1. Characterise the structure of an optimal solution.

2. Recursively define the value of an optimal solution.

3. Compute the value of an optimal solution, typically

in a bottom-up fashion.

4. Construct an optimal solution from the computed

information.

Famous Applications of Dynamic Programming are

0/1 Knapsack Proble
Matrix Chain Multiplicatio
All Pairs Shortest Path in Graphs
Types of Dynamic Programming Problems:
There are different types of problems that can be
solved using dynamic programming.

They usually vary on the type of tabulation approach

used or by using in combination with methods like Bit
masking.

Let’s look at each type of dynamic programming

problems
1 Dimensional Dynamic Programming

In this method, the problem can be easily solved by

using a one dimensional array.

Few examples for 1D Dynamic Programming

Stair Proble
Pairing Proble
Two Dimensional D
Bitwise Dynamic Programming

Stair Problem:

A person when running up a staircase with n steps and

can hop either 1 step, 2 steps, or 3 steps at a time.

For Example

Find out how many possible ways the person can run
up the stairs.

If there are 3 stairs in the staircase, the person can run

up in 4 ways.

The four ways:

1 step + 1 step + 1 ste

1 step + 2 ste
2 step + 1 ste
3 step

To implement a dynamic programming approach you

consider a tabular approach where initial values are
stored for a smaller number of steps.

Algorithm:
1. Create a 1d array dp of size n+1

2. Initialise the array with base cases as following

dp[0]=1, dp[1]=1, dp[2]=2.

3. Run a loop from 3 to n.

4. For each index i, compute the value of ith position

as dp[i] = dp[i-1] + dp[i-2] + dp[i-3].

That is to reach the ith stair, we count the number of

ways to reach (i-1)th stair + (i-2)th stair + (i-3)th stair
Print the value of dp[n], as the Count of the number
of ways to run up the staircase.

Complexity Analysis:

Time Complexity: O(n).

The array is traversed completely. So Time Complexity

is O(n).

Space Complexity: O(n).

To store the values in a dp array, ‘n’ extra space is

needed.

Pairing Problem:
Given the number of people to be ‘n’,every person can
either stay single or be paired with another person.
Each person can be paired only once.

Find the total number of combinations of pairs and

single people occurring for a given number of people.

For Example

Consider there are 3 people

n = 3

Possible combinations can be

{1}, {2}, {3} : all the people remain single

{1}, {2, 3} : 2 and 3 paired but 1 is single.

{1, 2}, {3} : 1 and 2 are paired but 3 is single.

{1, 3}, {2} : 1 and 3 are paired but 2 is single.

It should be noted that the order of pairings doesn't

matter that is {1,2} is same as {2,1}

There are 4 total combinations with 3 people.

Again the first step is to obtain a mathematical

relationship for ‘n’ and smaller values of n.

If you consider f(n) to denote the total number of

combinations for n people then for any f(n) there are

two possible cases:

The nth person can The nth person can be

remain single and paired with any of the

you have to remaining n-1 people,

calculate the and you have to

or
combinations for calculate the

remaining n-1 combinations for

people. remaining n-2 people (

as 2 people are paired )

So mathematically the relation obtained is

f(n)= f(n-1)+ (n-1)*f(n-2)

Next step, base cases have to be calculated and

initialised.

f(0)=1

f(1)=1

( 1 person has only one combination, remaining single)

f(2)=2

( 2 people have 2 combinations, either be paired or

both remain single)

The code can now be written as:

{ int countFriendsPairings(int n)

int f[n]; //array to store all pre

calculated values

//iterate through 3 to n

for (int i = 3; i <= n; i++) {

f[i] = f[i - 1] + (i - 1) * f[i - 2];

//for any n number of people, total

combinations are stored in f[n]

return f[n];

Two dimensional DP:

In two dimensional dynamic programming, we require

a 2d array to store the precalculated values.

In many problems, based on grids or graphs, we use

this kind of dynamic programming approach.

For Example

Given a grid or a two dimensional matrix with ‘m’ rows

and ‘n’ columns. Starting from (0,0), if you can only
move one step right or one step down, find the total
number of ways to reach a position (i,j) in the matrix.

As an example, consider that you want to reach the

position (1,2) from (0,0).

There are 3 possible paths that can be taken.

0 1 2 3

(0,0) (0,1) (0,2) (1,2)

 0 1 2 3 0 1 2 3

0 0
1 1
2 2
3 3

(0,0) (0,1) (0,0) (1,0)

(1,1) (1,2) (1,1) (1,2)

Therefore the number of ways to reach cell (i,j) will be

equal to the sum of number of ways of reaching (i-1,j)
and number of ways of reaching (i,j-1).

If we consider f(i,j) to represent the number of ways to

reach cell (i,j) in the matrix, the recurrence relation is
formed as:

f(i,j)=f(i-1,j) + f(i,j-1)

Therefore the number of ways to reach cell (i,j) will be

equal to the sum of number of ways of reaching (i-1,j)
and number of ways of reaching (i,j-1).

If we consider f(i,j) to represent the number of ways to

reach cell (i,j) in the matrix, the recurrence relation is
formed as:

f(i,j)=f(i-1,j) + f(i,j-1)

Similar to 1d dynamic programming problems, we

need to initialise the base cases.

In this problem, the base cases are the first row (in
yellow) and leftmost column (in green).

All the cells in the leftmost column can only be

reached in one way, by moving down from the cell
above them.

All the cells in the first row can only be reached in one
way, by moving right from the cell to the left of them.

The code can now be written as:

int countnoways(m,n)

//No of ways to reach (m,n)

//We can optimise space by creating grid of

m rows and n columns

int f[m][n];//declare the f matrix

f[0][0] = 1;

//base cases

//leftmost column

for (int i = 1; i < m; i++)

f[i][0] = 1;

//firstrow

for (int j = 1; j < n; j++)

f[0][ j] = 1;

for (int i = 1; i < m; i++) {

for (int j = 1; j < n; j++){

 //recurrence relation iterating from 1

f[i][j] = f[i - 1][j] + f[i][j - 1];

//no of ways to reach m,n is stored in f[m-1]

[n-1]

return f[m - 1][n - 1];

Complexity Analysis:
Time Complexity: O(m*n)

As we have iterated completely using two nested

loops.

Auxiliary Space : O(m*n)

For storing the values we used a two dimensional

array of m rows and n columns.

Bitwise Dynamic Programming

In this method, we generally use the concept of bit

masking for getting efficient solutions.

Bit masking basically refers to using integers as a way

to represent subsets of a given set of numbers using
binary representation.

For example consider a set A {1,3,4,6,2}

A subset of this set {1,3,4} can be represented as

0000….1101 in the form of binary.

Here if ith digit from right is 1, then the corresponding

‘i’ is present in the set.

So since, 1st, 3rd, 4th digits are 1’s in our binary

representation, the corresponding subset is {1,3,4}.

Now 000…1101 can be evaluated as the integer 13. So

the integer 13 is used to represent this particular
subset in bitmasking.

Problems that can be solved using Bit Masking and

Dynamic Programming together are:

→Count ways to assign unique cap to every person

https://www.geeksforgeeks.org/bitmasking-and-
dynamic-programming-set-1-count-ways-to-assign-
unique-cap-to-every-person/

https://bit.ly/2PIUjJp
→Number of ways to select n pairs of candies of
distinct colors

https://www.geeksforgeeks.org/count-ways-to-select-
n-pairs-of-candies-of-distinct-colors-dynamic-
programming-bitmasking/

https://bit.ly/3OycTiU
Must Do Problems in

Dynamic Programming :

0/1 Knapsack Problem

2. Count all increasing subsequences

3. Longest Palindromic Subsequence

4. Weighted job scheduling

5. Minimum Cost To Make Two Strings Identical

6. Longest Common Subsequence

7. Longest Increasing Subsequence

8. Coin Change Problem

9. Minimum Partition

10. Count all subsequences having product less than K

11. Maximum size square sub-matrix with all 1s

12. Largest Sum Contiguous Subarra y

13. Weighted Job Scheduling
14. Make Array Strictly Increasing
15. Max Sum of Rectangle No Larger Than K
16. Boolean Parenthesization Problem
17. Maximum difference of zeros and ones

in binary string
18. Largest Divisible Subset
19. Number of Submatrices That Sum to Target
20. Edit Distance
21. Interleaving String
22. Matrix Chain Multiplication