mi , j  min{d i 1.d k .

d j  mi ,k  mk 1, j }
ik  j

j-i=0 m1,1= 0 m2,2= 0 m3,3= 0 m4,4= 0 m5,5= 0 m6,6= 0

m1,2= m4,5= m5,6
m2,3=35*15*5 m3,4=15*5*10
j-i=1 30*35*15 = 5*10*20 = =10*20*25
= 2625 = 750
15750 1000 =5000
j-i=2 m1,3=7875 m2,4= 4375 m3,5= 2500 m4,6= 3500
j-i=3 m1,4= 9375 m2,5= 11375 m3,6= 5375
j-i=4 m1,5= 11875 m2,6= 18125
j-i=5 m1,6= 15125
d0=30 , d1= 35 , d2=15 , d3=5 , d4= 10 , d5=20 , d6=25

(k =1) => d0 d1 d3 + m1,1 + m2,3 =(30*35*5)+0+2625 =7875 (optimal)

m1,3= min { (k =2) => d0 d2 d3 + m1,2 + m3,3 =(30*15*5)+15750 +0 =18000
(k =2) => d1 d2 d4 + m2,2 + m3,4 =(35*15*10)+0+750=6000
m2,4= min { (k =3) => d1 d3 d4 + m2,3 + m4,4 =(35*5*10)+2625+0 =4375 (optimal)
(k =3) => d2 d3 d5 + m3,3 + m4,5 =(15*5*20)+0+1000=2500 (optimal)
m3,5= min { (k =4) => d2 d4 d5 + m3,4 + m5,5 =(15*10*20)+750+0 =3750
(k =4) => d3 d4 d6 + m4,4 + m5,6 =(5*10*25)+0+5000=6250
m4,6= min { (k =5) => d3 d5 d6 + m4,5 + m6,6 =(5*20*25)+1000+0 =3500 (optimal)

(k =1) => d0 d1 d4 + m1,1 + m2,4 =(30*35*10)+0+4375=14875

m1,4=min { (k =2) d0 d2 d4+ m1,2 + m3,4 =(30*15*10)+15750 + 750=21000

(k =3) => d0 d3 d4 + m1,3 + m4,4 =(30*5*10)+7875+0 =9375 (optimal)

(k =2) => d1 d2 d5 + m2,2 + m3,5 =(35*15*20)+0+2500 = 11500

m2,5=min { (k =3) d0 d1 d5+ m2,3 + m4,5 =(35*35*20)+2625+ 1000=28125

(k =4) => d1 d4 d5 + m2,4 + m5,5 =(35*10*20)+4375+0 =11375 (optimal)

(k =3) => d2 d3 d6 + m3,3 + m4,6 =(15*5*25)+0+3500= 5375(optimal)

m3,6=min { (k =4) d2 d4 d6+ m3,4 + m5,6 =(15*10*25)+750+ 5000=9500

(k =5) => d2 d5 d6 + m3,5 + m6,6 =(15*20*25)+2500 +0 = 10000

(k =1) => d0 d1 d5 + m1,1 + m2,5 =(30*35*20)+0+11375= 32375

(k =2) d0 d2 d5+ m1,2 + m3,5=(30*15*20)+15750+ 2500= 27250

m1,5=min { (k =3) => d0 d3 d5 + m1,3 + m4,5 =(30*5*20)+7875 +1000 =11875 (optimal)

(k =4) => d0 d4 d5 + m1,4 + m5,5 =(30*10*20)+9375 +0 = 15375

 (k =2) => d1 d2 d6 + m2,2 + m3,6 =(35*15*25)+0+5375= 18500

(k =3) d1 d3 d6+ m2,3 + m4,6 =(35*5*25)+2625+ 3500= 10500

m2,6=min { (k =4) => d1 d4 d6 + m2,4 + m5,6 =(35*10*25)+4375 +5000 = 18125 (optimal)

(k =5) => d1 d5 d6 + m2,5 + m6,6 =(35*20*25)+11375 +0 = 82875

(k =1) => d0 d1 d6 + m1,1 + m2,6 =(30*35*25)+0+18125 =39125 (optimal)

(k =2) d0 d2 d6+ m1,2 + m3,6 =(30*15*25)+15750+ 5375= 32375

m1,6=min { (k =3) => d0 d3 d6 + m1,3 + m4,6 =(30*5*25)+7875 +3500 = 15125 (optimal)

(k =4) => d0 d4 d6 + m1,4 + m5,6 =(30*10*25)+9375 +5000 =21875

(k =5) => d0 d5 d6 + m1,5 + m6,6 =(30*20*25)+11875 +0 = 26875

Reconstructing the solution: (M1 (M2 M3))((M4 M5) M6)

Rod_Cut (p, n)

Let r[0..n] be a new array

r[0] = 0

for j = 1 to n

q=-∞

for i = 1 to j

q = max (q , p[i] + r[j-i] )

r[j] = q

return r[n]

Time and space efficiencies of the algorithm is O(n2)

F[0] = 0
 n 0 1 2 3 4 5 6 7 8 9

F 0

F[1] = min {F[1-1]}+1 =0+1=1

n 0 1 2 3 4 5 6 7 8 9

F 0 1

F[2] = min {F[2-1]}+1 =1+1=2

n 0 1 2 3 4 5 6 7 8 9

F 0 1 2

F[3] = min { F[3-1] , F[3-3]}+1 =0+1=1

n 0 1 2 3 4 5 6 7 8 9

F 0 1 2 1

F[4] = min { F[4-1] , F[4-3]}+1 =1+1=2

n 0 1 2 3 4 5 6 7 8 9

F 0 1 2 1 2

F[5] = min { F[5-1] , F[5-3] , F[5-5]}+1 =0+1=1

n 0 1 2 3 4 5 6 7 8 9

F 0 1 2 1 2 1

F[6] = min { F[6-1] , F[6-3] , F[6-5]}+1 =1+1=2

n 0 1 2 3 4 5 6 7 8 9

F 0 1 2 1 2 1 2

F[7] = min { F[7-1] , F[7-3] , F[7-5]}+1 =2+1=3

n 0 1 2 3 4 5 6 7 8 9

F 0 1 2 1 2 1 2 3

F[8] = min { F[8-1] , F[8-3] , F[8-5]}+1 =1+1=2

n 0 1 2 3 4 5 6 7 8 9

F 0 1 2 1 2 1 2 3 2

F[9] = min { F[9-1] , F[9-3] , F[9-5]}+1 =2+1=3

n 0 1 2 3 4 5 6 7 8 9

F 0 1 2 1 2 1 2 3 2 3

Reconstructing the solution: 5,3,1

 i 0 1 2 3 4 5 6
0 0 0 0 0 0 0 0
1 0 0 0 25 25 25 25
2 0 0 20 25 25 45 45
3 0 15 20 35 40 45 60
4 0 15 20 35 40 55 60
5 0 15 20 35 40 55 65

Item3 The maximal value of a feasible subset is V [5, 6] = 65. The optimal subset is {item 3, item 5}.

b) 65 optimal solutions

c)The instance has a unique optimal subset in view of the following general property: An instance of
the knapsack problem has a unique optimal solution if and only if the algorithm for obtaining an
optimal subset, which retraces backward the computation of V [n, W], encounters no equality between
V [i − 1, j] and vi + V [i − 1, j − wi] during its operation.

a) Fib(n)
let fib[0..n] be a new array
fib[0] = fib[1] = 1
 for i = 2 to n
fib[i] = fib[i - 1] + fib[i - 2]
return fib[n]
b) There are n + 1 vertices in the subproblem graph, i.e., v0, v1,…, vn.
 For v0, v1, each has 0 leaving edge.
 For v2, v3, …, vn, each has 2 leaving edges.

Thus, there are 2n – 2 edges in the subproblem graph.

The Merge-Sort procedure does not have overlapping subproblems. In other word, all node of the
recursion tree are distinct (do not reuse the results of recursive call). That's why DP does not improve
the efficiency of The Merge-Sort procedure.

Yi 0 1 0 1 1 0 1 1 0
Xi 0 0 0 0 0 0 0 0 0 0
1 0 0 1 1 1 1 1 1 1 1
0 0 1 1 2 2 2 2 2 2 2
0 0 1 1 2 2 2 3 3 3 3
1 0 1 2 2 3 3 3 4 4 4
0 0 1 2 3 3 3 4 4 4 5
1 0 1 2 3 4 4 4 5 5 5
0 0 1 2 3 4 4 5 5 5 6
1 0 1 2 3 4 5 5 6 6 6
LCS= < 100110 >
 a.

B: 0.1 D: 0.15 -:0.15 C: 0.2 A: 0.4

b.
-:0.15 C: 0.2 A: 0.4
0.25

0 1

B: 0.1 D: 0.15

c. 0.
0.25 3 A: 0.4
5
0 1 0 1
B: 0.1 D: 0.15 -:0.15 C: 0.2

d.
A: 0.4
0.60

0 1

0.25 0.35

0 1 0 1
B: 0.1 D: 0.15 -:0.15 C: 0.2

e.
1.
00

0 1
A: 0.4
0.6
0
0 1

0.2 0.3
5 5

0 1 0 1
B: 0.1 D: 0.15 -:0.15 C: 0.2
Constructing the Huffman Code:
B: 100 D: 101 -:110 C: 111 A: 0