Dynamic Programming. Outline and Reading. Computing Fibonacci

Transcription

1 Dynamic Programming Dynamic Programming version Outline and Reading Matrix Chain-Product ( 5.3.1) The General Technique ( 5.3.2) -1 Knapsac Problem ( 5.3.3) Dynamic Programming version Computing Fibonacci Dynamic Programming is a general algorithm design paradigm: Iteratively solves small subproblems which are combined to solve overall problem. Fibonacci numbers defined F = F 1 = 1 F n = F n-1 + F n-2, for n > 1 Recursive solution: int fib(int x) if (x=) return ; else if (x=1) return 1; else return fib(x-1) + fib(x-2); Dynamic Programming Solution: f[]=; f[1]=1; for i 2 to x do f[i] f[i-1] + f[i-2]; return f[x]; Dynamic Programming version 1.2 3

2 Dynamic Programming revealed Brea problem into subproblems (Hardest part!) subproblems are shared optimal subproblem solution needs to help solve overall problem. (subproblem optimality) Compute solutions to small subproblems Store solutions in array A. Combine already computed solutions into solutions for larger subproblems Solutions Array A is iteratively filled (Optional: reduce space needed by reusing array) Dynamic Programming version Reducing Space for Computing Fibonacci store only previous 2 values to compute next value int fib(x) if (x=) return ; else if (x=1) return 1; else int last 1; nextlast ; for i 2 to x do temp last + nextlast; nextlast last; last temp; return temp; Dynamic Programming version Matrix Chain-Products Review: Matrix Multiplication. C = A*B A is d e and B is e f e 1 = C[ i, A[ i, ]* = O(def ) time (def multiplications) e e B f j d A i C i,j d Dynamic Programming version f

3 Matrix Chain-Products Matrix Chain-Product: Compute A=A *A 1 * *A n-1 A i is d i d i+1 Problem: How to parenthesize? [for minimizing ops] Example B is 3 1 C is 1 5 D is 5 5 (B*C)*D taes = 1575 ops B*(C*D) taes = 4 ops Dynamic Programming version An Enumeration Approach Matrix Chain-Product Alg.: Try all possible ways to parenthesize A=A *A 1 * *A n-1 Calculate number of ops for each one Pic the one that is best Running time: The number of paranethesizations is equal to the number of binary trees with n nodes This is exponential! It is called the Catalan number, and it is almost 4 n. This is a terrible algorithm! Dynamic Programming version A Greedy Approach Idea #1: repeatedly select the product that uses (up) the most operations. Counter-example: A is 1 5 B is 5 1 C is 1 5 D is 5 1 Greedy idea #1 gives (A*B)*(C*D), which taes = 2 ops A*((B*C)*D) taes = 1 ops Dynamic Programming version 1.2 9

4 Another Greedy Approach Idea #2: repeatedly select the product that uses the fewest operations. Counter-example: A is B is 11 9 C is 9 1 D is 1 99 Greedy idea #2 gives A*((B*C)*D)), which taes = ops (A*B)*(C*D) taes =1899 ops The greedy approach is not giving us the optimal value. Dynamic Programming version A Recursive Approach Define subproblems: Find the best parenthesization of A i *A i+1 * *A j. Let N i,j denote the number of operations done by this subproblem. The optimal solution for the whole problem is N,n-1. Subproblem optimality: The optimal solution can be defined in terms of optimal subproblems There has to be a final multiplication (root of the expression tree) for the optimal solution. Say, the final multiply is at index i: (A * *A i )*(A i+1 * *A n-1 ). Then the optimal solution N,n-1 is the sum of two optimal subproblems, N,i and N i+1,n-1 plus the time for the last multiply. If subproblems were not optimal, neither is global solution. Dynamic Programming version A Characterizing Equation Define global optimal in terms of optimal subproblems, by checing all possible locations for final multiply. Recall that A i is a d i d i+1 dimensional matrix. So, a characterizing equation for N i,j is the following: N i, j = j+ i < j min{ Ni, + N + 1, j + did+ 1d 1} Note that subproblems are not independent--the subproblems overlap (are shared) Dynamic Programming version

5 A Dynamic Programming Construct optimal subproblems bottom-up. N i,i s are easy, so start with them Then do length 2,3, subproblems, and so on. Array N i,j stores solutions Running time: O(n 3 ) matrixchain(s): Input: sequence S of n matrices to be multiplied Output: number of operations in an optimal paranthesization of S for i 1 to n-1 do N i,i for b 1 to n-1 do for i to n-b-1 do j i+b N i,j +infinity for i to j-1 do N i,j min{n i,j, N i, +N +1,j +d i d +1 d j+1 } Dynamic Programming version A Dynamic Programming Visualization Ni j The bottom-up construction fills in the N array by diagonals N i,j gets values from pervious entries in i-th row and j-th column Filling in each entry in the N table taes O(n) time. Total run time: O(n 3 ) Getting actual parenthesization can be done by remembering for each N entry, = j+ min{ Ni, + N+ 1, j + did+ 1d 1} i < j answer N 1 2 j 1 i n-1 n-1 Dynamic Programming version The General Dynamic Programming Technique Applies to a problem that at first seems to require a lot of time (possibly exponential), provided we have: Simple subproblems: the subproblems can be defined in terms of a few variables, such as j, l, m, and so on. Subproblem optimality: the global optimum value can be defined in terms of optimal subproblems Subproblem overlap: the subproblems are not independent, but instead they overlap (hence, should be constructed bottom-up). Dynamic Programming version

6 The /1 Knapsac Problem Given: A set S of n items, with each item i having b i - a positive benefit w i - a positive weight Goal: Choose items with maximum total benefit but with. If we are not allowed to tae fractional amounts, then this is the /1 napsac problem. In this case, we let T denote the set of items we tae Objective: maximize Constraint: w i W b i i T i T Dynamic Programming version Example Given: A set S of n items, with each item i having b i - a positive benefit w i - a positive weight Goal: Choose items with maximum total benefit but with. napsac Items: Weight: Benefit: in 2 in 2 in 6 in 2 in $2 $3 $6 $25 $8 9 in Solution: 5 (2 in) 3 (2 in) 1 (4 in) Dynamic Programming version A /1 Knapsac, First Attempt S : Set of items numbered 1 to. Define ] = best selection from S. Problem: does not have subproblem optimality: Consider S={(3,2),(5,4),(8,5),(4,3),(1,9)} benefit-weight pairs Best for S 4 : Best for S 5 : Dynamic Programming version

7 A /1 Knapsac, Second Attempt S : Set of items numbered 1 to. Define = best selection from S with weight exactly equal to w Good news: this does have subproblem optimality:, w w } if w else I.e., best subset of S with weight exactly w is either the best subset of S -1 w/ weight w or the best subset of S -1 w/ weight w-w plus item. Dynamic Programming version > w The /1 Knapsac Recall definition of : > w, w w } else 1Knapsac(S, W): Since is defined in Input: set S of items w/ benefit b i terms of -1,*], we can and weight w i ; max. weight W reuse the same array Output: benefit of best subset with Running time: O(nW). for w to W do Not a polynomial-time algorithm if W is large for 1 to n do This is a pseudo-polynomial for w W downto w do time algorithm if w-w ]+b > then w-w ]+b Dynamic Programming version Dynamic Programming revealed Brea problem into subproblems that are shared have subproblem optimality (optimal subproblem solution helps solve overall problem) subproblem optimality means can write recursive realtionship between subproblems! Compute solutions to small subproblems Store solutions in array A. Combine already computed solutions into solutions for larger subproblems Solutions Array A is iteratively filled (Optional: reduce space needed by reusing array) Dynamic Programming version

8 The /1 Knapsac Problem Given: A set S of n items, with each item i having b i - a positive benefit w i - a positive weight Goal: Choose items with maximum total benefit but with. If we are not allowed to tae fractional amounts, then this is the /1 napsac problem. In this case, we let T denote the set of items we tae Objective: maximize Constraint: w i W b i i T i T Dynamic Programming version Towards the /1 Knapsac S : Set of items numbered 1 to = {(b 1,w 1 ), (b 2,w 2 ),, (b,w )} Define = maximum benefit of optimal subset from S with total weight at most j Recursive definition of :, j w } if = otherwise Dynamic Programming version Towards the /1 Knapsac if =, j w } otherwise rec1knap(s, W): = maximum benefit Input: set S of items w/ benefit b 1, b 2, b of optimal subset from S,; weights w 1, w 2, w j and max. weight W with total weight at most j Output: benefit of best subset with Recursive version of if = then {S = emptyset} algorithm based on return recursive subproblem remove item (benefit-weight (b,w )) relationship. from S Not a dynamic if w > W then {item does not fit} return rec1knap(s,w) programming version. return max(rec1knap(s,w), rec1knap(s,w-w ) + b ) Dynamic Programming version

9 Towards the /1 Knapsac Modified recursive version that stores subproblem solutions First allocate global array B of size n+1 by W Then initialize all entries of i, to 1 B stores results of recursive calls Entries in B are computed when necessary This is considered a dynamic programming version., j w ] + b } if = otherwise rec1knap(s, W): Input: set S of items w/ benefit b 1, b 2,,b,; weights w 1, w 2, w j and max. weight W Output: benefit of best subset with if = then return remove item (benefit-weight (b,w )) from S if -1, W]= 1 then -1,W]=rec1Knap(S,W) if w > W then return -1, W] if -1, W- w ]= 1 then -1,W - w ]=rec1knap(s,w -w ) return max(-1, W], -1,W - w ]+b ) Dynamic Programming version The /1 Knapsac - Iterative if =, j w } otherwise 1Knapsac(S, W): Input: set S of n items w/ benefit b Recursive computation i and weight w i ; max. weight W not necessary Output: benefit of best subset with Compute iteratively, for w to W do {base case} bottom-up, All -1,*] must be for 1 to n do computed before *] for j 1 to W do because of subproblem if w then dependencies -1, else This is also dynamic max(-1,, programming. -1,j-w Dynamic Programming version 1.2 ]+b ) 26 The /1 Knapsac - Iterative if =, j w } otherwise 1Knapsac(S, W): Input: set S of n items w/ benefit b Not necessary to use all the i and weight w i ; max. weight W space Output: benefit of best subset with Keep trac of one row at a time for w to W do {base case} Overwrite results from, previous row as new values for 1 to n do computed for j W downto 1 do Must compute right to left (W if w then downto 1) so that the next -1, row (*]) uses results from else the previous row (-1,*]). max(-1,, Simplify this to get version in -1, j-w ]+b ) boo. Dynamic Programming version

10 The /1 Knapsac - Iterative if =, j w } otherwise 1Knapsac(S, W): Input: set S of n items w/ benefit b Not necessary to use all the i and weight w i ; max. weight W space Output: benefit of best subset with Keep trac of one row at a time for w to W do {base case} Overwrite results from previous row as new values for 1 to n do computed for j W downto 1 do Must compute right to left (W if w then downto 1) so that the next row (*]) uses results from else the previous row (-1,*]). max(, Simplify this to get version in j-w ]+b ) boo. Dynamic Programming version The /1 Knapsac > w, w w } else 1Knapsac(S, W): The boo version: Input: set S of n items w/ benefit b i When value does not change and weight w i ; max. weight W from one row to the next, Output: benefit of best subset with then no need to assign same value. for w to W do Running time: O(nW). Not a polynomial-time for 1 to n do algorithm if W is large for w W downto w do This is a pseudo-polynomial if w-w ]+b > then time algorithm w-w ]+b Dynamic Programming version