Homework3: Dynamic Programming - Answers

Transcription

1 Most Exercises are from your textbook: Homework3: Dynamic Programming - Answers 1. For the Rod Cutting problem (covered in lecture) modify the given top-down memoized algorithm (includes two procedures) to compute and return not only the optimal revenue, but also necessary data (the S-list) that will help to later print the optimal solution. CutRod_DP_memoized(N, P) //given the size of the rod and the list of N prices 1 Define a new array R[0..N] 2 Define a new array S[1..N] //an array to save the length of the first cut for every length rod 3 for i=0 to N 4 R[i]= - //Can initialize with -1 too since revenue-values are nonnegative 5 return CutRod_aux(N, P, R, S) CutRod_aux(n, P, R, S) 1 if R[n] >= 0 //Check if there is a registered value for r n 2 return (R[n], S) 4 if n==0 5 R[n] = 0 //Register the optimal revenue (no S-value to register) 7 max = - //lines 7-12: compute max revenue r n = max 1 i n ( p i + r n i ) and save the optimal cut 8 for i = 1 to n //i is the length of the left piece 9 temp = P[i]+CutRod_aux(n-i, P, R, S).firstValue //take 1 st value of the returned pair 10 if (max < temp) 11 max = temp 12 S[n] = i //Save the length of the optimal cut for an n-length rod 13 R[n] = max //Register the optimal revenue 14 return (R[n], S) 2. Consider a modification of the Rod Cutting Problem where in addition to a price p i for each i-length rod, each cut incurs a fixed cost of c. The revenue associated with a solution is now the sum of prices of all pieces minus the costs of making the cuts. Give a dynamic programming algorithm to solve this modified problem. CutRod(n, P, c) 1 Define R[1..n] array 2 Define S[1..n] array //Array to save left-piece lengths 3 R[0] = 0 //Register the optimal revenue //won t need this 4 for size = 1 to n //for every length rod find out its optimal revenue 5 max = P[size] //lines 5-9: compute r size =max{p size, max 1 i size 1 ( p i + r size i c) 6 for i = 1 to size-1 //i is the length of the left piece 7 if (max < P[i] + R[size-i] - c) 8 max = P[i] +R[size-i] - c 9 S[size] = i //Save the i that gave the max revenue 10 R[size] = max //Register the optimal revenue for size-length rod 11 return R[n] and The main changes here are (presented in green in the pseudocode): 1. The revenue that is obtained by making a cut is computed as: price of the left piece + max revenue of the remainder cost of the cut. 2. Since the option of not cutting at all does not incur any c-cost, it is taken out of the maxcomputing loop the revenue in this case is simply the price of the piece (it s different than cases that make a cut). This means that we do not need to define R[0]=0 fictitious revenue. 3. Suppose that in the original Rod Cutting Problem we also had limit l i on the number of pieces of length i that we are allowed to produce, for i=1,2, n. Show that the optimal substructure property no longer 1

2 holds (you can show it by giving an example where the optimal solution of the problem contains a nonoptimal solution of a sub-problem). This solution text is from your textbook authors (Cormen, Leiserson, Rivest and Stein): We say that a problem exhibits the optimal substructure property when optimal solutions to a problem incorporate optimal solutions to related sub-problems which we may solve independently (i.e. they do not share resources). When we impose a limit l i on the number of pieces of size i that we are permitted to produce, the sub-problems can no longer be solved independently. For example, consider a rod of length 4 with the following prices and limits: Length i Price p i Limit l i This instance has only three solutions that do not violate the limits: length 4 with price 36; lengths 1 and 3 with price 48; and lengths 1, 1, and 2 with price 50. The optional solution, therefore is to cut into lengths 1, 1, and 2. When we look at sub-problem for length 2, it has two solutions that do not violate the limits: length 2 with price 20, and lengths 1 and 1 with price 30. The optimal solution for length 2, therefore is to cut into lengths 1 and 1. But we cannot use this solution of the sub-problem in the optimal solution for the original problem because it would result in using four rods of length 1 to solve the original problem, violating the limit of two length-1 rods. 4. Applying the bottom-up dynamic programming algorithm for the Matrix-Chain Multiplication Problem (covered in lecture), find an optimal parenthesization of the matrix-chain product A 1 A 2 A 3 A 4 A 5 A 6 ; the sequence of matrix-dimensions is <50,10,3,12,5,50,6>. a) Draw the M and S tables, compute and fill-in values. M-table S-table b) Using the S table, produce the fully parenthesized product for the given matrix chain. A 1..6 = ( A 1..2 A 3..6 ) = ( ( A 1..1 A 2..2 ) ( A 3..4 A 5..6 ) ) = ( ( A 1 A 2 ) ( ( A 3..3 A 4..4 ) ( A 5..5 A 6..6 ) ) ) = = ( ( A 1 A 2 ) ( ( A 3 A 4 ) ( A 5 A 6 ) ) ) 5. For the Matrix-Chain Multiplication problem: a) Give the pseudocode of a naïve recursive algorithm to compute the min cost of the product of the chain (no need to construct the optimal solution just compute the value of the solution). //The initial call to this recursive routine will be MatrixChain_recursive(P, 1, N) MatrixChain_recursive(P, i, j) //given P list of matrix-sizes, and i,j indexes of sub-chain A i..j 1 if i==j 2 return 0 4 M[i,j] = //lines 4-8: find min cost of A i..k A k+1..j products for all possible k-values 5 for k=i to j-1 6 x = MatrixChain_recursive(P,i,k) + MatrixChain_recursive(P,k+1,j) + P[i-1] P[k] P[j] 7 if x < M[i,j] 8 M[i,j] = x 9 return M[i,j] 2

3 b) Give the pseudocode of a memoized top-down algorithm (two procedures) to compute the min cost of the product (no need to construct the optimal solution just compute the value of the solution). MatrixChain_memoized(P) //given the list of N+1prices 1 N =P.lenght-1 2 Define a new table M[1..N, 1..N] 3 for i=1 to N 4 for j=i to N 5 M[i,j]= 6 return MatrixChain_aux(M,P,1,N) MatrixChain_aux(M,P,i,j) //given M-table, P list of matrix-sizes, and i,j indexes of sub-chain A i..j 1 if M[i,j] < //Check if min cost for A i..j product is already computed, and if so, return that value 2 return M[i,j] 4 if i==j 5 M[i,j]=0 //Register the min cost 7 for k=i to j-1 //lines 7-11: find min cost of A i..k A k+1..j products for all possible k-values 8 x = MatrixChain_aux(M,P,i,k) + MatrixChain_aux(M,P,k+1,j) + P[i-1] P[k] P[j] 9 if x < M[i,j] 10 M[i,j] = x //Register the min cost 11 return M[i,j] 6. Applying the bottom-up dynamic programming algorithm for the Longest Common Subsequence Problem (covered in lecture), determine the LCS for the following two sequences: <1,0,0,1,0,1,0,1> and <0,1,0,1,1,0,1,1,0>. a) Draw the C and B tables, compute and fill-in values. C-table B-table l d l d d l d d l d l d l l d l l d d l d l l d l l d u d l d d l d d l d u d l l d l l d u d u d d l d d l d u d u l d l l d u d u d d l d d l b) Using the B table, produce the LCS for the given two sequences. An LCS of the given two sequences <1,0,0,1,0,1,0,1> and <0,1,0,1,1,0,1,1,0> is <0,1,0,1,0,1> Note: the route is shown in green on B-table above. //Continued on the next page 3

4 7. Give pseudocode to reconstruct an LCS from the completed C table and the original sequences X = <x 1,x 2,,x m > and Y = <y 1,y 2,,y n > in O(n+m) time without using the B-table. LCS_output(C, X, Y) 1 Define an empty string output 2 i=m //starting with the [m,n] cell 3 j=n 4 while i>0 and j>0 //as long as we didn t hit the #0-row or the #0-column 5 if X[i] == Y[j] //if two symbols match, then C[i,j] was obtained from diagonal element 6 output = x[i] + output //add i-symbol of X (same as j-symbol in Y) to the output 7 i=i-1 //move to the diagonal-cell 8 j=j-1 9 else 10 if C[i,j] == C[i,j-1] //if C[i,j] is obtained from the left C-value 11 j=j-1 //move to left-cell 12 else 13 i=i-1 //move to up-cell 14 return output //or we can print the output here and be done 8. For the Longest Common Subsequence Problem: a) Give the pseudocode of a naïve recursive algorithm to compute the length of the LCS of given two sequences (no need to construct the optimal solution just compute the value of the solution). //The initial call to this recursive routine will be LCS_recursive(X,Y,m,n) LCS_recursive(X,Y,i, j) //given X,Y sequences and the number of elements in prefixes X i and Y j 1 if i==0 or j==0 2 return 0 4 if x i == y j 5 return LCS_recursive(X,Y,i-1,j-1) return max{ LCS_recursive(X,Y,i-1,j), LCS_recursive(X,Y,i,j-1)} b) Give the pseudocode of memoized top-down algorithm (two procedures) to compute the length of LCS of given 2 sequences (no need to construct optimal solution just compute the value of the solution). LCS_memoized(X,Y) //given X and Y sequences 1 m =X.lenght 2 n = Y.length 3 Define a new table C[1..m, 1..n] 4 for i=1 to m 5 for j=1 to n 6 C[i,j]= -1 7 return LCS_aux(C,X,Y,m,n) LCS_aux(C,X,Y,i, j) //given C-table, X,Y sequences and the number of elements in prefixes X i,y j 1 if C[i,j] >=0 //Check if the length of LCS(X i,y j ) is already computed, and if so, return that value 2 return C[i,j] 4 if i=0 or j=0 5 C[i,j] = 0 //Register the max length 7 if x i == y j //Compute and register max length in both cases 8 C[i,j] = LCS_aux(C,X,Y,i-1,j-1) else 10 C[i,j] = max{ LCS_aux(C,X,Y,i-1,j), LCS_aux(C,X,Y,i,j-1)} 11 return C[i,j] 4

5 9. Applying the bottom-up dynamic programming algorithm for the Knapsack 0-1 Problem (covered in lecture), determine the subset of items that should be selected to go into the knapsack for the following input data: W weight-limit is 8, N number of items is 4, prices of items are $15, $10, $9, $5 and their weights are 1,5,3,4 respectively. a) Draw the V and B tables, compute and fill-in values. V-table i\w B-table i\w b) Using the B table, produce the subset of items chosen to go into the knapsack. The following is the work on B-table (the route is shown in green on B-table above). B[4,8] ==1, thus item 4 is chosen and we move to [3, 8-4=4] cell. B[3,4] ==1, thus item 3 is chosen and we move to [2,4-3=1] cell. B[2,1] ==0 which means that item 2 is not chosen so we move to [1,1] cell. B[1,1] ==1 thus item 1 is chosen. Items 4, 3, and 1 (or 1,3,4) are the optimal choice to go into the knapsack. 10. Draw the execution tree for MergeSort algorithm on an array of 16 elements (draw the tree of all subproblems that occur); remember that the recursive routine, call it shortly MS, is defined to work on an array segment A i..j, with the initial call to be made for A Explain why memoization fails to speed up a good divide-and-conquer algorithm such as MergeSort. MS MS 1..8 MS MS 1..4 MS 5..8 MS MS MS 1..2 MS 3..4 MS MS 7..8 MS MS MS MS MS 1 MS 2 MS 3 MS 4 MS 5 MS 6 MS 7 MS 8 MS 9 MS 10 MS 11 MS 12 MS 13 MS 14 MS 15 MS 16 Note: in this tree MS i..j stands for Mergesort(A i..j ) and MS i stands for MergeSort(A i..i ). In a good divide-and-conquer algorithm all sub-problems are distinct (they do not overlap). This means that each sub-problem is solved only once and therefore memoization does not speed up the algorithm. On the contrary, memoization is inefficient because (i) it uses additional memory to save computed values, and (ii) does additional work with the data-structure containing the already computed values. 5