- 1. Below is a dynamic programming solution for this problem to illustrate how it can be used. There is a very straightforward O(1) time solution. It can be shown that à¤‡à¤« n >= 50 then any solution will include a set of coins that adds to exactly 50 cents.

Hence it can be shown that an optimal solution uses 2 · [n/50 ] quarters along with un optimal solution for making n/50 − bn/50c cents which can be looked up in a table à¤‘à¤«़ size 50.

Here’s the dynamic programming solution for this problem. (It does not use the à¤«à¤•्à¤¤ that an optimal solution can be proven to use 2 · bn/50c quarters and hence is not à¤…à¤¸ efficient.) The general subproblem will be to make change for i cents for 1 i n. Let

c[i] denote the fewest coins needed to make i cents. Then we can define c[i] recursively

by:

c[i] =

8><

>:

use i pennies if 1 i < 9

c[i − 10] + 1 if 10 i < 24

min(c[i − 10] + 1, c[i − 25] + 1) if i 25

Note that c[n] is the optimal number of coins needed for the original problem.

Clearly when i < 10 the optimal solution can use only pennies (since that is the

only coin available). Otherwise, the optimal solution either uses a dime or a quarter

and both of these are considered. Finally, the optimal substructure property clearly

holds since the final solution just adds one coin to the subproblem solution. There

are n subproblems each of which takes O(1) time to solve and hence the overall time

complexity is O(n). - Recall that D1 is a DNA sequence with n1 characters and D1 is a DNA sequence with

n2 characters. The general form of the subproblem we solve will be: Find the best

alignment for the first i characters of D1 and the first j characters of D2 for 1 i n1

and 1 j n2. Let D(i) be the ith character in string D. Let c[i, j] be the cost of

an optimal alignment for D1(1), . . . ,D1(i) and D2(1), . . . ,D2(j). We can define c[i, j]

recursively as shown (where c[n1, n2] gives the optimal cost to the original problem):

c[i, j] =

8>>><

>>>: i

if j

=

0

j if i = 0

c[i − 1, j − 1] if D1(i) = D2(j)

min{c[i − 1, j − 1], c[i − 1, j], c[i, j − 1]} + 1 otherwise

We now argue this recursive definition is correct. You can form D01 and D02 (and hence

the alignment) for the subproblem from the right to left as follows. In an optimal

alignment either the last character of D01 is a space or it is the last character (character

i) of D1 and the last character of D02 is a space or it is the last character (character

j) of D2. If D1(i) = D2(j) then clearly it is best to align them (so add a space to

neither). However, if D1(i) 6= D2(j) then a space could be added to neither or just

one. In all three cases one mismatch is caused by the last characters. Notice that

there would never be any benefit in ending both D1 and D2 with a space. Hence the

above recursive definition considers all possible cases that the optimal alignment could

have. Since the solution to the original problem is either the value of the subproblem

solution (if D1(i) = D2(j)) or otherwise one plus the subproblem solution, the optimal

substructure property clearly holds. Thus the solution output is correct.

For the time complexity it is clearly O(n1 · n2) since there are n1 · n2 subproblems each

of which is solved in constant time. Finally, the c[i, j] matrix can be computed in row

major order and just as in the LCS problem a second matrix that contains which of

the above 4 cases was applied can also be stored and then used to construct an optimal

alignment. - Let m[i] be the rental cost for the best solution to go from post i to post n for 1 i n.

The final answer is in m[1]. We can recursively, define m[i] as follows:

m[i] =

8<

:

0 if i = n

min

i

(fi,j + m[j]) otherwise

We now prove this is correct. The canoe must be rented starting at post i (the starting

location) and then returned next at a station among i + 1, . . . , n. In the recurrence

we try all possibilities (with j being the station where the canoe is next returned).

Furthermore, since fi,j is independent from how the subproblem of going from post

j, . . . , n is solved, we have the optimal substructure property.

For the time complexity there are n subproblems to be solved each of which takes

O(n) time. These subproblems can be computed in the order m[n],m[n−1], . . . ,m[1].

Hence the overall time complexity is O(n2).

NOTE: One (of several) alternate general subproblem form that also leads to an O(n2)

algorithm is to find the best solution to get from post i to post n where the canoe

cannot be exchanged until post j is reached (for 1 i < j n). - The general form of the subproblem we solve will be: determine if z1, . . . , zi+j is an

interleaving of x1, . . . , xi and y1, . . . yj for 0 i m and 0 j n. Let c[i, j] be

true if and only if z1 . . . , zi+j is an interleaving of x1, . . . , xi and y1, . . . , yj . We use the

convention that if i = 0 then xi = (the empty string) and if j = 0 then yj = . The

subproblem c[i, j] can be recursively defined as shown (where c[m, n] gives the answer

to the original problem):

c[i, j] =

8>>>>>><

>>>>>>:

true if i = j = 0

false if xi 6= zi+j and yj 6= zi+j

c[i − 1, j] if xi = zi+j and yj 6= zi+j

c[i, j − 1] if xi 6= zi+j and yj = zi+j

c[i − 1, j] _ c[i, j − 1] if xi = yj = zi+j

We now argue this recursive definition is correct. First the case where i = j = 0 is

when both X and Y are empty and then by definition Z (which is also empty) is a

valid interleaving of X and Y . If xi 6= zi+j and yj = zi+j then there could only be a

valid interleaving in which xi appears last in the interleaving, and hence c[i, j] is true

exactly when z1, . . . , zi+j−1 is a valid interleaving of x1, . . . , xi−1 and y1, . . . yj which is

given by c[i − 1, j]. Similarly, when xi 6= zi+j and yj = zi+j then c[i, j] = c[i − 1, j].

Finally, consider when xi = yj = zi+j . In this case the interleaving (if it exists) must

either end with xi (in which case c[i − 1, j] is true) or must end with yi (in which

case c[i, j − 1] is true). Thus returning c[i − 1, j] _ c[i, j − 1] gives the correct answer.

Finally, since in all cases the value of c[i, j] comes directly from the answer to one of

the subproblems, we have the optimal substructure property.

The time complexity is clearly O(nm) since there are n ·m subproblems each of which

is solved in constant time. Finally, the c[i, j] matrix can be computed in row major

order.

## 0 comments:

## Post a Comment