Design and Analysis

of
Advanced Algorithm

Md. Manowarul Islam

Assistant Professor
Dept. Of CSE
Jagannath University, Bangladesh
 Dynamic Programming

• An algorithm design technique (like divide and

conquer)
• Divide and conquer
– Partition the problem into independent subproblems

– Solve the subproblems recursively

– Combine the solutions to solve the original problem

2
 DP - Two key ingredients
• Two key ingredients for an optimization problem
to be suitable for a dynamic-programming
solution:

1. optimal substructures 2. overlapping subproblems

Subproblems are dependent.

Each substructure is (otherwise, a divide-and-
optimal. conquer approach is the
(Principle of optimality) choice.) 3
 Three basic components

• The development of a dynamic-programming

algorithm has three basic components:
– The recurrence relation (for defining the value of an
optimal solution);
– The tabular computation (for computing the value of
an optimal solution);
– The traceback (for delivering an optimal solution).

4
 Fibonacci numbers

The Fibonacci numbers are defined by the

following recurrence:

F 0
0
F 1
1
F F   F  for i>1 .
i i 1 i 2

5
How to compute F10 ？

F8
F9
F7 ……
F10
F7
F8
F6

6
 Dynamic Programming
• Applicable when subproblems are not independent
– Subproblems share subsubproblems
E.g.: Fibonacci numbers:
• Recurrence: F(n) = F(n-1) + F(n-2)
• Boundary conditions: F(1) = 0, F(2) = 1
• Compute: F(5) = 3, F(3) = 1, F(4) = 2
– A divide and conquer approach would repeatedly solve the
common subproblems
– Dynamic programming solves every subproblem just once and
stores the answer in a table

7
 Tabular computation
• The tabular computation can avoid
recompuation.

F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10

0 1 1 2 3 5 8 13 21 34 55

Result

8
 Dynamic Programming Algorithm
1. Characterize the structure of an optimal
solution
2. Recursively define the value of an optimal
solution
3. Compute the value of an optimal solution in a
bottom-up fashion
4. Construct an optimal solution from computed
information

9
 The Knapsack Problem
• The 0-1 knapsack problem
– A thief robbing a store finds n items: the i-th item is
worth vi dollars and weights wi pounds (vi, wi
integers)
– The thief can only carry W pounds in his knapsack
– Items must be taken entirely or left behind
– Which items should the thief take to maximize the
value of his load?
• The fractional knapsack problem
– Similar to above
10
– The thief can take fractions of items
 The 0-1 Knapsack Problem

• Thief has a knapsack of capacity W

• There are n items: for i-th item value vi and

weight wi

• Goal:
– find xi such that for all xi = {0, 1}, i = 1, 2, .., n

 wixi  W and

 xivi is maximum
11
 0-1 Knapsack - Greedy Strategy
• E.g.:

Item 3 30 $120

Item 2 50 50 50 +
20 $100
Item 1 30
20 + 20 $100
10 10 $60

$60 $100 $120 $160 $220

$6/pound $5/pound $4/pound

• None of the solutions involving the greedy

choice (item 1) leads to an optimal solution
– The greedy choice property does not hold

12
0-1 Knapsack - Dynamic Programming

• P(i, w) – the maximum profit that can be

obtained from items 1 to i, if the
knapsack has size w
• Case 1: thief takes item i

P(i, w)vi=+ P(i - 1, w-wi)

• Case 2: thief does not take item i

P(i, w)P(i
= - 1, w)
13
 0-1 Knapsack - Dynamic Programming

Item i was taken Item i was not taken

P(i, w) = max {vi + P(i - 1, w-wi), P(i - 1, w) }

0: 1 w - wi w W

0 0 0 0 0 0 0 0 0 0 0 0
0 first

0 second
i-1 0
i 0
0
n 0
14
 W = 5 Item Weight Value
Example:
P(i, w) = max {vi + P(i - 1, w-wi), P(i - 1,1 2 12
2 1 10
w) } 3 3 20
0 1 2 3 4 5
4 2 15
0 0 0 0 0 0 0 P(1, 1) = P(0, 1) = 0
1 0 0 12 12 12 12 P(1, 2) = max{12+0, 0} = 12
2 0 10 12 22 22 22 P(1, 3) = max{12+0, 0} = 12
3 0 10 12 22 30 32 P(1, 4) = max{12+0, 0} = 12
4 0 10 15 25 30 37 P(1, 5) = max{12+0, 0} = 12

P(2, 1)= max{10+0, 0} = 10 P(3, 1)= P(2,1) = 10 P(4, 1)= P(3,1) = 10

P(2, 2)= max{10+0, 12} = 12 P(3, 2)= P(2,2) = 12 P(4, 2)= max{15+0, 12} = 15
P(2, 3)= max{10+12, 12} = 22 P(3, 3)= max{20+0, 22}=22 P(4, 3)= max{15+10, 22}=25
P(2, 4)= max{10+12, 12} = 22 P(3, 4)= max{20+10,22}=30 P(4, 4)= max{15+12, 30}=30
P(2, 5)= max{10+12, 12} = 22 P(3, 5)= max{20+12,22}=32 P(4, 5)= max{15+22, 32}=37
15
Reconstructing the Optimal Solution
0 1 2 3 4 5
0 0 0 0 0 0 0 • Item 4
1 0 0 12 12 12 12
• Item 2
2 0 10 12 22 22 22
3 0 10 12 22 30 32 • Item 1
4 0 10 15 25 30 37

• Start at P(n, W)
• When you go left-up  item i has been taken
• When you go straight up  item i has not been
taken
16
Knapsack Problem by DP (pseudocode)
18
Rock Climbing Problem

19
 Rock Climbing Problem
• A rock climber wants to get from
the bottom of a rock to the top
by the safest possible path.

• At every step, he reaches for

handholds above him; some
holds are safer than other.

• From every place, he can only

reach a few nearest handholds.
 Rock climbing (cont)

Suppose we have a
wall instead of the rock. 4
5 3
2
At every step our climber can reach exactly three
handholds: above, above and to the right and
above and to the left.

There is a table of “danger ratings” provided. The

“Danger” of a path is the sum of danger ratings of
all handholds on the path.
 Rock Climbing (cont)
•We represent the wall as a 22 8 9 55 8
table.
4 44 6 22 3
•Every cell of the table contains 5 7 5 6 11
the danger rating of the 3 22 5 44 8
corresponding block.
The obvious greedy algorithm does not give an
optimal solution. The rating of this path is 13.
The rating of an optimal path is 12.
However, we can solve this problem by a
dynamic programming strategy in polynomial
time.
Idea: once we know the rating of a path to
every handhold on a layer, we can easily
compute the ratings of the paths to the
holds on the next layer.

For the top layer, that gives us an

answer to the problem itself.
For every handhold, there is only one
“path” rating. Once we have reached a
hold, we don’t need to know how we got
there to move to the next level.

This is called an “optimal substructure” property.

Once we know optimal solutions to
subproblems, we can compute an optimal
solution to the problem itself.
Recursive solution:

To find the best way to get to stone j in row

i, check the cost of getting to the stones
• (i-1,j-1),
• (i-1,j) and
• (i-1,j+1), and take the cheapest.

Problem: each recursion level makes three

calls for itself, making a total of 3n calls –
too much!
Solution - memorization

We query the value of A(i,j) over and over

again.
Instead of computing it each time, we can
compute it once, and remember the value.

A simple recurrence allows us to compute

A(i,j) from values below.
 Dynamic programming

• Step 1: Describe an array of values you want

to compute.

• Step 2: Give a recurrence for computing later

values from earlier (bottom-up).

• Step 3: Give a high-level program.

• Step 4: Show how to use values in the array

to compute an optimal solution.
 Rock climbing: step 1.

• Step 1: Describe an array of values you want

to compute.

• For 1  i  n and 1  j  m, define A(i,j) to

be the cumulative rating of the least
dangerous path from the bottom to the hold
(i,j).

• The rating of the best path to the top will be

the minimal value in the last row of the array.
 Rock climbing: step 2.
• Step 2: Give a recurrence for computing later values from
earlier (bottom-up).

• Let C(i,j) be the rating of the hold (i,j). There are three cases for
A(i,j):

• Left (j=1): C(i,j)+min{A(i-1,j),A(i-1,j+1)}

• Right (j=m): C(i,j)+min{A(i-1,j-1),A(i-1,j)}

• Middle: C(i,j)+min{A(i-1,j-1),A(i-1,j),A(i-1,j+1)}

• For the first row (i=1), A(i,j)=C(i,j).

 Rock climbing: simpler step 2

• Add initialization row: A(0,j)=0. No danger to stand

on the ground.

• Add two initialization columns:

A(i,0)=A(i,m+1)=. It is infinitely dangerous to try to
hold on to the air where the wall ends.

• Now the recurrence becomes, for every i,j:

A(i,j) = C(i,j)+min{A(i-1,j-1),A(i-1,j),A(i-1,j+1)}
 Rock climbing: example
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0  0 0 0 0 0 
4 4 6 2 3 1  
2 8 9 5 8 2  
3  
4  

Initialization: A(i,0)=A(i,m+1)=, A(0,j)=0

 Rock climbing: example
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0  0 0 0 0 0 
4 4 6 2 3 1  3 2 5 4 8 
2 8 9 5 8 2  
3  
4  

The values in the first row are the same as C(i,j).

 Rock climbing: example
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0  0 0 0 0 0 
4 4 6 2 3 1  3 2 5 4 8 
2 8 9 5 8 2  7 
3  
4  

A(2,1)=5+min{,3,2}=7.
 Rock climbing: example
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0  0 0 0 0 0 
4 4 6 2 3 1  3 2 5 4 8 
2 8 9 5 8 2  7 9 
3  
4  

A(2,1)=5+min{,3,2}=7. A(2,2)=7+min{3,2,5}=9
 Rock climbing: example
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0  0 0 0 0 0 
4 4 6 2 3 1  3 2 5 4 8 
2 8 9 5 8 2  7 9 7 
3  
4  

A(2,1)=5+min{,3,2}=7. A(2,2)=7+min{3,2,5}=9
A(2,3)=5+min{2,5,4}=7.
 Rock climbing: example
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0  0 0 0 0 0 
4 4 6 2 3 1  3 2 5 4 8 
2 8 9 5 8 2  7 9 7 10 5 
3  
4  

The best cumulative rating on the second row is 5.

 Rock climbing: example
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0  0 0 0 0 0 
4 4 6 2 3 1  3 2 5 4 8 
2 8 9 5 8 2  7 9 7 10 5 
3  11 11 13 7 8 
4  

The best cumulative rating on the third row is 7.

 Rock climbing: example
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0  0 0 0 0 0 
4 4 6 2 3 1  3 2 5 4 8 
2 8 9 5 8 2  7 9 7 10 5 
3  11 11 13 7 8 
4  13 19 16 12 15 

The best cumulative rating on the last row is 12.

 Rock climbing: example
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0  0 0 0 0 0 
4 4 6 2 3 1  3 2 5 4 8 
2 8 9 5 8 2  7 9 7 10 5 
3  11 11 13 7 8 
4  13 19 16 12 15 

The best cumulative rating on the last row is 12.

So the rating of the best path to the top
is 12.
 Rock climbing example: step 4
C(i,j): A(i,j):

3 2 5 4 8 i\j 0 1 2 3 4 5 6
5 7 5 6 1 0  0 0 0 0 0 
4 4 6 2 3 1  3 2 5 4 8 
2 8 9 5 8 2  7 9 7 10 5 
3  11 11 13 7 8 
4  13 19 16 12 15 

To find the actual path we need to retrace backwards

the decisions made during the calculation of A(i,j).
 Rock climbing example: step 4
C(i,j): A(i,j):
i\j 0 1 2 3 4 5 6
3 2 5 4 8
0  0 0 0 0 0 
5 7 5 6 1
1  3 2 5 4 8 
4 4 6 2 3
2  7 9 7 10 5 
2 8 9 5 8
3  11 11 13 7 8 
The last hold was (4,4). 4  13 19 16 12 15 

To find the actual path we need to retrace backwards

the decisions made during the calculation of A(i,j).
 Rock climbing example: step 4
C(i,j): A(i,j):
i\j 0 1 2 3 4 5 6
3 2 5 4 8
0  0 0 0 0 0 
5 7 5 6 1
1  3 2 5 4 8 
4 4 6 2 3
2  7 9 7 10 5 
2 8 9 5 8
3  11 11 13 7 8 
The hold before the last 4  13 19 16 12 15 
was (3,4), since
min{13,7,8} was 7.

To find the actual path we need to retrace backwards

the decisions made during the calculation of A(i,j).
 Rock climbing example: step 4
C(i,j): A(i,j):
i\j 0 1 2 3 4 5 6
3 2 5 4 8
0  0 0 0 0 0 
5 7 5 6 1
1  3 2 5 4 8 
4 4 6 2 3
2  7 9 7 10 5 
2 8 9 5 8
3  11 11 13 7 8 
The hold before that 4  13 19 16 12 15 
was (2,5), since
min{7,10,5} was 5.

To find the actual path we need to retrace backwards

the decisions made during the calculation of A(i,j).
 Rock climbing example: step 4
C(i,j): A(i,j):
i\j 0 1 2 3 4 5 6
3 2 5 4 8
0  0 0 0 0 0 
5 7 5 6 1
1  3 2 5 4 8 
4 4 6 2 3
2  7 9 7 10 5 
2 8 9 5 8
3  11 11 13 7 8 
Finally, the first hold 4  13 19 16 12 15 
was (1,4), since
min{5,4,8} was 4.

To find the actual path we need to retrace backwards

the decisions made during the calculation of A(i,j).
 Rock climbing example: step 4
C(i,j): A(i,j):
i\j 0 1 2 3 4 5 6
3 2 5 4 8
0  0 0 0 0 0 
5 7 5 6 1
1  3 2 5 4 8 
4 4 6 2 3
2  7 9 7 10 5 
2 8 9 5 8
3  11 11 13 7 8 
4  13 19 16 12 15 

We are done!
 Printing out the solution recursively
PrintBest(A,i,j) // Printing the best path ending at (i,j)
if (i==0) OR (j=0) OR (j=m+1)
return;
if (A[i-1,j-1]<=A[i-1,j]) AND (A[i-1,j-1]<=A[i-1,j+1])
PrintBest(A,i-1,j-1);
elseif (A[i-1,j]<=A[i-1,j-1]) AND (A[i-1,j]<=A[i-1,j+1])
PrintBest(A,i-1,j);
elseif (A[i-1,j+1]<=A[i-1,j-1]) AND (A[i-1,j+1]<=A[i-1,j])
PrintBest(A,i-1,j+1);
printf(i,j)