Chapter 5:- DYNAMIC PROGRAMMINGsvbitce2010.weebly.com/uploads/8/4/4/5/8445046/che_5.pdf · In...

Chapter 5:-

DYNAMIC PROGRAMMING

Compiled By:- Sanjay Patel

Assistant Professor,

SVBIT.

Outline

Introduction

The Principle of Optimality,

Problem Solving using Dynamic Programming –

Calculating the Binomial Coefficient

Making Change Problem

Assembly Line-Scheduling

Knapsack problem

Shortest path

Matrix chain multiplication,

Longest Common Subsequence..

Sanjay Patel

Dynamic programming is technique for solving

problems with overlapping sub problems.

In this method each sub problem is solved only once.

The result of each sub problem is recorded in a

table from which we can obtain a solution to the

original problem.

Introduction

Sanjay Patel

Divide and Conquer Dynamic programming

The problem is divide into small sub problems.

These sub problem are solved independently.

Finally all the solution of sub problem are

collected together to get the solution to the

given problem

In dynamic programming many decision

sequences are generated and all the

overlapping sub instances are considered.

In this method duplication in sub solution are

neglected. i.e. duplicate sub solution may be

obtained.

In dynamic computing duplication in solutions is

avoided totally.

less efficient because of rework on solution efficient than divide and conquer strategy.

uses top down approach of problem solving-

Recursive method

uses bottom up approach of problem solving-

Iterative method.

splits its input at specific deterministic points

usually in the middle.

Splits its input at every possible splits points

rather than at a particular point. After trying all

split points it deterministic which split point is

optimal.

Difference between divide and conquer

Sanjay Patel

Greedy method Dynamic Programming

Is used for obtaining optimum

solution

Is also for obtaining optimum

solution

In greedy a method a set of

feasible solutions and the picks up

the optimum solution

There is no special set of feasible

solutions in this method

The optimum selection is without

revising previously generated

solution

It consider all possible sequence in

order to obtain the optimum

solution

There is no such guarantee of

getting optimum solution

It is guaranteed that the dynamic

programming will generate

optimal solution using principal of

optimality.

Greedy Algo vs. Dynamic Algo

Sanjay Patel

The dynamic programming algorithm obtains the

solution using principle of optimality

The principle of optimality states that “ in an

optimal sequence of decision or choices, each

subsequence must also be optimal.

When it is not possible to apply the principle of

optimality it is almost impossible to obtain the

solution using the dynamic programming approach.

Principle of optimality

Sanjay Patel

Suppose, the following coins are available.

1 Dollar = 100 cents

1 Quarter = 25 cents

1 Dimes = 10 cents

1 Nickels = 5 cents

1 pennies = 1 cents

For example customer wants to pay 3.37 $.

3.37$ = 3 dollar + 1 quarter + 1 dime + 2 pennies

Making change problem

Sanjay Patel

Another example, if there exits coins of 1, 4 , 6 units.

We have to make change for 9 units.

There are two ways.

1. Greedy method:- select one coin of 6 unit and 3

coin of 1 unit = 4 coins.

2. Better method:- select two coins of 4 units and 1

coin of 1 unit = 3 coins.

This better method is devised by dynamic programming

approach.

Cont’d..

Sanjay Patel

There are 3 exits coins of 1 ,4 and 6 unit. We have

to make change for 9 units. Solve this problem with

dynamic programming.

Solution:- For solving this problem using dynamic

programming approach, we need to build up table.

Here, d1=1 , d2=4 , d3=6 , n=3, N=9 units.

Hence we will create a table with rows ranging from

1 to 3 and columns ranging from 0 to 9.

Example of making change

Sanjay Patel

1. If i=1 then c[ i , J ] = 1+ c [ 1, J- d1]

2. If J < di then c[ i , J ] = c [ i-1, J]

3. Otherwise, C[i] [J] = min ( c[i-1,J], 1+ c[i, J- di])

Initially c[i,0] = 0

So, c[1,0] = 0

c[2,0] = 0

c[3,0] = 0

Condition for equation

Sanjay Patel

J

i=1

i=2

i=3

Table

Sanjay Patel

0 1 2 3 4 5 6 7 8 9

d1= 1 0

d1= 4 0

d1= 6 0

C[1,1] with i=1 , J=1 , and d1=1

formula 1 :-If i=1 then c[ i , J ] = 1+ c [ 1, J- d1]

C[1,1] = 1+ c [ 1, 1- 1]

= 1 + c [ 1, 0]

= 1 + 0

= 1

Cont’d..

Sanjay Patel

C[2,1] with i=2 , J=1 and d2=4

As J < d2 i.e 1< 4

formula 2:- If J < di then c[ i , J ] = c [ i-1, J]

C[2,1] = c [ i-1, J]

= c [ 2-1 , 1]

= c [1,1]

= 1

Cont’d..

Sanjay Patel

C[3,1] = 1 , C[1,2] = 2 , C[2,2] = 2 , C[3,2] = 2

C[1,3] = 3 , C[2,3] = 3 , C[3,3] = 3 , C[1,4] = 4.

For C[2,4] with i=2 , J=4 and d2=4

As i≠1 and J>d2

Formula 3 :-min ( c[i-1,J], 1+ c[i, J- di])

C[2,4]= min ( c[2-1,4] , 1+ c[2,4-4] )

= min ( c [1,4] , 1 + c [2,0]

= min ( 4 , 1+0 )

= 1

Cont’d..

Sanjay Patel

C[3,4] = 1 , C[1,5] = 5 , C[2,5] = 2 , C[3,5] = 2

C[1,6] = 6 , C[2,6] = 3 , C[3,6] = 1 , C[1,7] = 7

C[2,7] = 4 , C[3,7] = 2 , C[1,8] = 8 , C[2,8] = 2

C[3,8] = 2 , C[1,9] = 9, C[2,9] = 3 , C[3,9] = 3

Cont’d..

Sanjay Patel

J

i=1

i=2

i=3

The value c[n,N] i.e c[3,9] = 3 represents the minimum

number coins required to get the sum for 9 units. Hence we

require 3 coins for getting 9 units.

4 units + 4 units + 1 units = 9 units

1 coin + 1 coin + 1 coin = 3 coins

Table

Sanjay Patel

0 1 2 3 4 5 6 7 8 9

d1= 1 0 1 2 3 4 5 6 7 8 9

d1= 4 0 1 2 3 1 2 3 4 2 3

d1= 6 0 1 2 3 1 2 1 2 2 3

For( i 1 to n ) do

c[ i, 0] 0

For ( i 1 to n ) do // initially first column by 0

{ for ( J 1 to N) do // with this loop table are computed

{ if (i=1 && J< d[i]) then

c[i][J] = infinity;

else if (i=1) then

c[i][J] = 1+ c [ 1, J- d1];

else if (j<d[i]) then

c[i][J] = c [ i-1, J];

else

c[i][J] = min ( c[i-1,J], 1+ c[i, J- di]) } }

return c [ n , N ] // total number of coins in the change

Algorithm

Sanjay Patel

As the basic operation in above algorithm is to fill

up the table, which is performed within nested for

loops.

Hence, the time complexity of this algorithm is

(nN).

Analysis ( complexity )

Sanjay Patel

Dynamic programming is a technique for solving

problems with overlapping sub problems.

These sub problem are typically based on recurrence

relation.

To solve knapsack problem using dynamic approach ,

we will write the recurrence relation.

Knapsack problem

Sanjay Patel

Table[i,J] = maximum { table[i-1,J], Vi + table[i-1,J-wi] }

if J >= wi

OR

= table [i-1,J] if J < wi

That means a table is constructed using above given formula.

Initially table [0,J]=0 as well as table[i,0]=0 when J>=0

i>=0

Formula

Sanjay Patel

For the given instance of problem obtain the optimal

solution for the knapsack problem using dynamic

programming.

The capacity of knapsack is W=5

Example

Sanjay Patel

Item Weight Value

1 2 3

2 3 4

3 4 5

4 5 6

Initially table[0,J]=0 and table[i,0]=0. there are 0

to n rows and 0 to W columns in the table.

0 1 2 3 4 5

0

1

2

3

4

Cont’d..

Sanjay Patel

0 0 0 0 0 0

0

0

0

0

Table[1,1] with i=1 , J=1 , Wi=2 and Vi=3

As J < Wi

table[1,1] = table [i-1,J]

= table [1-1,1]

= table[0,1]

= 0

Cont’d..

Sanjay Patel

Table[1,2] with i=1 , J=2 , Wi=2 and Vi=3

As J>=Wi

table[1,2] = maximum { table[i-1,J], Vi + table[i-1,J-wi] }

= maximum { table[1-1,2], 3+table[1-1,2-2] }

= maximum { table[0,2], 3+0 }

= maximum { 0 , 3 }

= 3

Cont’d..

Sanjay Patel

table[1,3]=3 , table[1,4]=3 , table[1,5]=3


table[2,4]=4 , table[2,5]=7

table[3,1]=0 table[3,2]=3 , table[3,3]=4

table[3,4]=5 , table[3,5]=7


table[4,4]=5 , table[4,5]=7

Cont’d..

Sanjay Patel

Finally, we can get the table given below

0 1 2 3 4 5

0

1

2

3

4

Cont’d..

Sanjay Patel

0 0 0 0 0 0

0 0 3 3 3 3

0 0 3 4 4 7

0 0 3 4 5 7

0 0 3 4 5 7

Let, i=n and k=W

While(i>0 and k>0)

{ if ( table[i , k]≠ table[i-1 , k] ) then

mark ith item as in kanpsack

i = i-1 and k= k - Wi // selection of ith item

else

i = i-1 // do not select ith item

}

How to find actual knapsack item?

Sanjay Patel

Thus we have selected item 1 and item 2 for the

knapsack.

So the solution can be represented in vector as below.

( 1 , 1 , 0 , 0 )

Solution

Sanjay Patel

For( i 0 to n ) do

{

For ( J 0 to W ) do

{ table[i,0]=0

table[0,J]=0 // table initialization

}}

for ( i 0 to n) do

{

for (J 0 to W) do

{ if (J< W[i]) then

table[i,J] table [i-1,J]

else if (J>=W[i]) then

table[i,J] maximum { table[i-1,J], Vi + table[i-1,J-wi] }

}}

return table[n,W]

Algorithm

Sanjay Patel

In this algorithm basic operation is if….else if

statement within two nested for loops.

So, n W

C(n)= ∑ ∑1i=0 J=0

n

= ∑ (W-0+1)

i=0

Analysis

Sanjay Patel

n n

C(n)= w ∑ 1 + ∑ 1i=0 i=0

= W( n-0+1) +(n-0+1)

= Wn+W+n+1

C(n)=Wn

The time complexity of this algorithm is (Wn)

Cont’d..

Sanjay Patel

Solve the following 0/1 knapsack problem using dynamic

programming. There are five items whose weights and values are

given as below.

weight W[] = { 1 , 2 , 5 , 6 , 7 }

Value V[] = { 1 , 6 , 18 , 22 , 28 }

Show your equation and find out the optimal knapsack items for weight

and capacity of 11 units.

Another Example ( GTU 2010 )

Sanjay Patel

Item Weight Value

1 1 1

2 2 6

3 5 18

4 6 22

5 7 28

The capacity W=11.

Initially table , table[0,J]=0 and table[i,0]=0.

There are 0 to n rows and 0 to W columns.

table[1,1] with i=1 , J=1 , Wi=1 and Vi=1 J>=Wi

table[1,1] = maximum { table[i-1,J], Vi + table[i-1,J-wi] }

= max { table[0,1] , 1 + table[0,0] }

= max{ 0,1}

= 1

Solution

Sanjay Patel

0 0 0 0 0 0 0 0 0 0 0 0

0 1

0

0

0

0

Cont’d…

Sanjay Patel

0

1

2

3

4

5

0 1 2 3 4 5 6 7 8 9 10 11

0 0 0 0 0 0 0 0 0 0 0 0

0 1 1 1 1 1 1 1 1 1 1 1

0 1 6 7 7 7 7 7 7 7 7 7

0 1 6 7 7 18 19 24 25 25 25 25

0 1 6 7 7 18 22 24 28 29 29 40

0 1 6 7 7 18 22 28 29 34 35 40

After Computing

Sanjay Patel

0

1

2

3

4

5

0 1 2 3 4 5 6 7 8 9 10 11

After applying algorithm, we find final solution

which is ,we have selected item 3 and item 4 for

the knapsack.

The total profit = 18 + 22 =40

After applying algorithm

Sanjay Patel

Computing binomial co efficient is a typical example

of applying dynamic programming.

In mathematics, the binomial coefficient is denoted by

C(n , k).

The formula for computing binomial coefficient is,

C(n,k)= C(n-1, k-1) + C(n-1, k)

And C(n,0)=1

C(n,n)=1 where n > k > 0

Calculating the binomial coefficient

Sanjay Patel

Here n=4,k=2

C(4,2)= C(n-1, k-1) + C(n-1, k)

= C(3,1) + C(3,2)

There are two unknown C(3,1) and C(3,2).

Now, compute C(3,1) where n=3 and k=1

C(3,2)= C(n-1, k-1) + C(n-1, k)

= C(2,0) + C(2,1)

We can write C(n,0)=1

C(2,0)=1

Example (compute(4,2) )

Sanjay Patel

C(3,1)= 1 + C(2,1)

Now let us compute C(2,1) where n=2, K=1

C(2,1)= C(n-1, k-1) + C(n-1, k)

= C(1,0) + C(1,1)

But as, C(n,0)=1 and C(n,n)=1

Then we can get, C(1,0)=1 and C(1,1)=1

C(2,1)= 1 + 1 =2 so we will get rest of the value,

C(3,1)=3 , C(3,2)=3 , C(4,2)=6

C(4,2)= 6 is the final Answer.

Cont’d..

Sanjay Patel

While computing C(n,k) the smaller overlapping

sequence get generated by C(n-1, k-1) and C(n-1 ,k).

These overlapping smaller instance of problem need

to be solved first.

If we record binomial coefficients n and k values

ranging from 0 to n and 0 to k then.

How dynamic programming approach is used?

Sanjay Patel

0 1 2 3 4 …… ……. k-1 k

0 1

1 1 1

2 1 2 1

3 1 3 3 1

4 1 4 6 4 1

……

…..

…

(n-1)

n

Cont’d..

Sanjay Patel

0 1

1 1 1

2 1 2 1

3 1 3 3 1

4 1 4 6 4 1

5 1 5 10 10 5 1

6 1 6 15 20 15 6 1

Pascal’s triangle ( compute(6,3) )

Sanjay Patel

C(6,3) = 20

for(i 0 to n) do

{ for (J 0 to k) do

{

if ((J=0 or (i=J)) then

C[i,J] 1

else

C[i,J] C[i-1,J-1] + C[i-1,J]

}

return C[n , k]

The time complexity of binomial coefficient is (nk)

Algorithm & complexity

Sanjay Patel

The all pair shortest path is the problem of

determining shortest path distances between every

pair of vertices in a given graph.

The use of this algorithm is in routing problems.

We will discuss floyd-warshall’s algorithm.

Shortest path

Sanjay Patel

Floyd-warshall’s algorithm is for finding the shortest

path between every pair of vertices of a graph.

This algorithm is invented by R.Floyd and hence is

the name.

Floyd computes the distance matrix of a weighted

graph with n vertices through a series of n by n

matrices.

Floyd-warshall’s algorithm.

Sanjay Patel

Floyd-Warshall’s Algorithm

Sanjay Patel

The weight matrix and the graph

1 2 3 4 5

1 0 1 1 5

2 9 0 3 2

3 0 4

4 2 0 3

5 3 0

v1 v2

v3v4

v5

32

2

4

1

3

1

93

5

for(k 1 to n) do

{

for(i 1 to n) do

{

for(J 1 to n) do

{

D[i,J] min { D[i,J] , (D[i,k] + D[k,J]) }

}}}

return D // computed D(n) is returned

Algorithm

Sanjay Patel

In above algorithm the basic operation is

D[i,J] min { D[i,J] , (D[i,k] + D[k,J])

This operation is with in three nested for loops.

So, the time complexity of finding all pair shortest

path is ( n3 )

Analysis

Sanjay Patel

Example..

Sanjay Patel

W = D0 =

40 5

2 0

-3 0

1 2 3

1

2

3

1

2

3

5

-3

24

Cont’d

Sanjay Patel

D1 =40 5

2 0 7

-3 0

1 2 3

1

2

3

1

2

3

5

-3

24k = 1

Vertex 1 can be

intermediate node

D[i,J] = min { D[i,J] , (D[i,k] + D[k,J]) }

D1[2,3] = min( D0[2,3], D0[2,1]+D0[1,3] )

= min ( , 7)

= 7

40 5

2 0

-3 0

1 2 3

1

2

3

D0 =

Cont’d..

Sanjay Patel

D[i, J] = min { D[i,J] , (D[i,k] + D[k,J]) }

D1[3,2] = min( D0[3,2], D0[3,1]+D0[1,2] )

= min (-3, )

= -3

40 5

2 0 7

-3 0

1 2 3

1

2

3

D1 =

Cont’d

Sanjay Patel

D2 =

40 5

2 0 7

-1 -3 0

1 2 3

1

2

3


D2[1,3] = min( D1[1,3], D1[1,2]+D1[2,3] )

= min (5, 4+7)

= 5

1

2

3

5

-3

24 D1 =

40 5

2 0 7

-3 0

1 2 3

1

2

3

k = 2

Vertices 1, 2 can

be intermediate


D2[3,1] = min( D1[3,1], D1[3,2]+D1[2,1] )

= min ( , -3+2)

= -1

Cont’d..

Sanjay Patel

40 5

2 0 7

-1 -3 0

1 2 3

1

2

3

D2 =

Cont’d..

Sanjay Patel

D3 =

20 5

2 0 7

-1 -3 0

1 2 3

1

2

3


D3[1,2] = min(D2[1,2], D2[1,3]+D2[3,2] )

= min (4, 5+(-3))

= 2

D2 =

40 5

2 0 7

-1 -3 0

1 2 3

1

2

3

1

2

3

5

-3

24k = 3

Vertices 1, 2, 3

can be

intermediate


D3[2,1] = min(D2[2,1], D2[2,3]+D2[3,1] )

= min (2, 7+ (-1))

= 2

Cont’d..

Sanjay Patel

20 5

2 0 7

-1 -3 0

1 2 3

1

2

3

D3 =

Another Example

Sanjay Patel

D0

Sanjay Patel

D1

Sanjay Patel

D2

Sanjay Patel

D3

Sanjay Patel

D4

Sanjay Patel

D5

Sanjay Patel

efficiently multiply a chain of N matrices, i.e. calculate in the

fastest way

Example: consider the chain A1, A2, A3, A4 of 4 matrices

Let us compute the product A1A2A3A4

There are 5 possible ways:

1. (A1(A2(A3A4)))

2. (A1((A2A3)A4))

3. ((A1A2)(A3A4))

4. ((A1(A2A3))A4)

5. (((A1A2)A3)A4)

Matrix Chain Multiplication

Sanjay Patel

For each i, which within range of 1 to n and for each J

which within a range of 1 to n the optimal cost m[i,J] is

computing using following formula.

m[i,i]=0 where 1<=i<=n for all i

m[i, J] = min {m[i, k] + m[k+1, J ] + pi-1* pk * pJ }

for i ≤ k < J

Recursive solution

Sanjay Patel

We will construct table of m[i,J] using formula

1. m[i,i]=0 for i=1 to n

2. For length 2 to n compute

m[i, J] = min { m[i, k] + m[k+1, J ] + Pi-1* Pk * PJ }

for i ≤ k < J

Computing optimal cost

Sanjay Patel

Consider,

We have to compute matrix in chain order,

Here, P0=5 , P1=4 , P2=6 , P3=2 , P4=7

Example

Sanjay Patel

Matrix Dimension

A1 5 * 4

A2 4 * 6

A3 6 * 2

A4 2 * 7

Step-1 . For all i 1 <=i <=n

so, m[i,i]=0

Then , m[1,1]=0 , m[2,2]=0 , m[3,3]=0 , m[4,4]=0

Solution

Sanjay Patel

Sanjay Patel

Let i=1 , J=2 , k=1

Calculate m[1,2]

Sanjay Patel

Sanjay Patel

m[1,4] determines the optimal cost =158.

Build up s table using s[i, J]=k

Sanjay Patel

for (i 1 to n) do

m[i, i] 0

for (length 2 to n) do // is the chain length.

{ for (i 2 to (n − length + 1) ) do

{ J i + length − 1

m[i, J] Infinity

for (k i to J − 1) do

{ q m[i, k] + m[k + 1, j] + pi−1*pk* pJ

if (q < m[i, j]) then

{ m[i, J] q

s[i, J] k }}}}

return m[1,n] and s

Algorithm

Sanjay Patel

The basic operation in this algorithm is computation

of m[i,J] and s[i,J] which is within three nested for

loops.

Hence the time complexity of the above algorithm is

(n3)

Analysis

Sanjay Patel

Let , B=<b1,b2….bn> and A=<a1,a2,…..an> be

string over an alphabet. Then B is a subsequence of

A if B can generated by striking out some element

from A.

For example, two string s1=abbacdcba,

s2=bcdbbcaaac

So, s1 is a subsequence of s2.

The longest common subsequence problem is the

problem of finding given two sequence A and Ba

maximum length common subsequence of A and B.

Let us apply dynamic programming steps.

Longest Common subsequence

Sanjay Patel

Let c[i,J] be the length of an LCS of Ai and Bi then we

get a recursive definition:

= 0 if i=0 or J=0

C[i, J] = C[i-1,J-1]+1 if i,J>0 and Ai=BJ

= max( c[i,J-1], c[i-1,J]) if i,J>0 and Ai ≠ BJ

Recursive Definition

Sanjay Patel

m length (A)

n length (B)

for(i1 to m) do

{ c[i,0] 0

} for(J 0 to n) do

{ c[0,J] 0

}

// making first row and column zero.

Continue algorithm.

Computing LCS

Sanjay Patel

for(i 1 to m) do

{ for(J 1 to n) do

{ if(ai ==bi) then

{ c[i,J] c[i-1,J-1]+1

d[i,J] “ “ } //Putting direction.

else if(c[i-1, J] >= c[ i , J-1]) then

{ c[i,J] c[i-1,J]

d[i,J] “ “ }

else { c[i, J] c[i , J-1]

d[i,J] “ “ }}}

return c and d.

Algorithm

S anjay Patel

Let A =< X , Y , Z , Y , T , X , Y>

B =< Y , T , Z , X , Y , X>

1 2 3 4 5 6 7

A[i]

B[i]

Example

Sanjay Patel

X Y Z Y T X Y

Y T Z X Y X

We will build c[i,J] and d[i, J].

Initially, c[i,0] 0 where i represent row and

c[0,J] 0 where J represent column

Solution

Sanjay Patel

0 0 0 0 0 0 0

0

0

0

0

0

0

0

for(i1 to m) and

for(J1 to n)

We will filling up c[i,J] and d[i,J] horizontally,

Let i=1 , J=1

1 2 3 4 5 6 7

A[i]

B[J]

Cont’d..

Sanjay Patel

X Y Z Y T X Y

Y T Z X Y X

As if( A[ i ] ≠ B [ J ] ) // first condition

else if(c[i-1, J] >= c[ i , J-1])

else if ( c[0,1] >= c [1,0] ) which is true //second cond.

0 >= 0

c[1,1] c[i-1 , J]

c[0,1]

0

And d[1,1] “ “

C[1,1] i=1, J=1

Sanjay Patel

0 1 2 3 4 5 6

0

1

2

3

4

5

6

7

Cont’d..

Sanjay Patel

0 0 0 0 0 0 0

0 0

0

0

0

0

0

0


else if(c[i-1, J] >= c[ i , J-1])


0 >= 0

c[1,1] c[i-1 , J]

c[0,1]

0

And d[1,1] “ “

C[1,2] i=1 , J=2

Sanjay Patel

0 1 2 3 4 5 6

0

1

2

3

4

5

6

7

Cont’d..

Sanjay Patel

0 0 0 0 0 0 0

0 0 0

0

0

0

0

0

0


else if(c[i-1, J] >= c[ i , J-1])


0 >= 0

c[1,1] c[i-1 , J]

c[0,1]

0

And d[1,1] “ “

C[1,3] i=1 , J=3

Sanjay Patel

0 1 2 3 4 5 6

0

1

2

3

4

5

6

7

Cont’d..

Sanjay Patel

0 0 0 0 0 0 0

0 0 0 0

0

0

0

0

0

0

As if( A[ i ] = B [ J ] ) // first condition

which is true

c[i,J] c[i-1, J-1] + 1

c[1,4] c[1-1 , 4-1] + 1

c[0,3] + 1

1

And d[1,4] “ “

C[1,4] i=1 , J=4

Sanjay Patel

0 1 2 3 4 5 6

0

1

2

3

4

5

6

7

Cont’d..

Sanjay Patel

0 0 0 0 0 0 0

0 0 0 0 1

0

0

0

0

0

0

0 1 2 3 4 5 6

0

1

2

3

4

5

6

7

Cont’d..

Sanjay Patel

0 0 0 0 0 0 0

0 0 0 0 1 1 1

0 1 1 1 1 2 2

0 1 1 2 2 2 2

0 1 1 2 2 3 3

0 1 2 2 2 3 3

0 1 2 2 3 3 4

0 1 2 2 3 4 4

display_LCS ( d , A[] , i , J)

if ( i=0 !! J=0 ) then

return;

if( d[i,J] = “ “ ) then

{ display LCS(d , A , i-1 , J-1)

print(ai) }

else if ( d[i,J] = “ “ ) then

{ display LCS(d , A , i-1 , J) }

else {

display LCS(d , A , i , J-1) }

Constructing LCS

Sanjay Patel

YZYX is your LCS.

Answer

Sanjay Patel

Chapter 5:- DYNAMIC PROGRAMMINGsvbitce2010.weebly.com/uploads/8/4/4/5/8445046/che_5.pdf · In...

Documents

Transcript of Chapter 5:- DYNAMIC PROGRAMMINGsvbitce2010.weebly.com/uploads/8/4/4/5/8445046/che_5.pdf · In...