Lecture 4: Dynamic programming I

Transcription

1 Lecture : Dynamic programming I Dynamic programming is a powerful, tabular method that solves problems by combining solutions to subproblems. It was introduced by Bellman in the 950 s (when programming meant planning ), and is typically applied to optimization problems. Dynamic programming is used to solve problems which have overlapping subproblems. Each subproblem is solved only once and the solution stored in a table for later lookup. Four steps in the development of a dynamic programming algorithm:. Characterize the structure of an optimal solution.. Recursively define the value of an optimal solution.. Compute the value of an optimal solution bottom-up.. Construct an optimal solution from computed information. Rod cutting Given a rod of length n cm and a table of prices p i, for i =,...,n, determine the maximum revenue r n for cutting up the rod in lengths l i. There are n different cuttings, since we may or may not cut at distance l cm from the left end, for l =,...,n. If an optimal solution cuts the rod into k pieces, for some k n, then an optimal decomposition n = l + + l k gives maximum revenue r n = p l + + p lk. The problem has optimal substructure: optimal solutions to a problem incorporate optimal subsolutions, solved independently. We have Recursive top-down implementation: r n = max l n (p l + r n l ), with r 0 = 0 CUT-ROD(p, n) if n = 0 return 0 for l to n do q max(q,p[l] + CUT-ROD(p,n l)) return q The running time is Θ( n ), which we can reduce to Θ(n ) by using dynamic programming: BOTTOM-UP-CUT-ROD(p, n) let r[0..n] be a new array r[0] 0 for j to n do for l to j do q max(q,p[l] + r[j l]) r[j] q return r[n]

2 The doubly-nested loop gives Θ(n ) time complexity. Reconstructing a solution: EXTENDED-BOTTOM-UP-CUT-ROD(p, n) let r[0..n] and s[0..n] be new arrays r[0] 0 for j to n do for l to j do if q < p[l] + r[j l] then q p[l] + r[j l] s[j] l r[j] q return r and s Matrix-chain multiplication Given a sequence A,A,...,A n of n matrices, insert parentheses that determine the order of multiplication in a way that minimizes the number of scalar multiplications. Note that the number of ways to parenthesize is given by the Catalan numbers: C(n) = n k= C(k) C(n k) = n + ( ) n = Ω( n n n /) Let A i have dimension p i p i. If A is a p 0 p matrix and A a p p matrix, then their product matrix is a p 0 p matrix. The number of scalar multiplications is p 0 p p. Example: A = [0 0], A = [0 50], A = [50 ], A = [ 00] A (A (A A )) requires operations (A (A A )) A requires.00 operations Step : Structure of an optimal parenthesization If it is optimal to split A i A i+ A j between A k and A k+, then the parenthesizations of A i A k and A k+ A j must be optimal. If there were better ways to parenthesize subproblems this would produce a better parenthesization of A i A j. Step : A recursive solution Let m[i,j] denote the minimum cost for A i A j }. m[i,j] = 0 if i = j min i k<j (m[i,k] + m[k +,j] + p i p k p j ) if i < j A i A k } is a p i p k -matrix and A k+ A j } a p k p j -matrix.

3 Step : Computing the optimal costs Dynamic programming finds the cheapest order by computing m[i, j] by increasing differences j i:. m[i,i] = 0, for all i.. m[i, i + ], from the recursive equation.. m[i,i + ], etc. Thereby m[i,k] and m[k+,j] exist when m[i,j] shall be computed, which then takes O(j i) = O(n) time to find best k. The number of subproblems for i j n is O(n ). Hence the total time is O(n ). In the example above: p 0 = 0, p = 0, p = 50, p = p = 00.?? j 00? k= i m[,] = min m[,] + m[,] + p0 p p = 00 m[,] + m[,] + p 0 p p = 0500 correspond to A (A A ) and (A A ) A. m[,] + m[,] + p p m[,] = min p = m[,] + m[,] + p p p = 000 correspond to A (A A ) and (A A ) A. This gives k = for? in the figure. For the top square in the table the optimal multiplication order is (A (A A )) A (i.e. k = for?? in the figure) since m[,] + m[,] + p 0 p p = = 000 m[,] = min m[,] + m[,] + p 0 p p = = m[,] + m[,] + p 0 p p = = 00 m[,n] gives the minimum number of scalar multiplications for the whole problem. Step : Constructing an optimal solution Index k in a square [i,j] gives the optimal split of A i A j as (A i A k ) (A k+ A j ).

4 Elements of dynamic programming Two ingredients that an optimization problem must have for dynamic programming to be applicable:. Optimal substructure. An optimal solution contains optimal subsolutions since otherwise we may get a better solution by improving subsolutions. Determine which combination of subproblems achieves the best solution. We consider the number of subproblems to combine and the number of choices we have in determining which subproblem(s) to use in the solution. Note that subproblems are independent in the sense that the solution to one subproblem does not affect the solution to another. In rod cutting, an optimal solution uses just one subproblem (of size n l) but must consider n choices for l. In matrix-chain multiplication we use two subproblems but have j i choices to consider.. Overlapping/repeated subproblems. Dynamic programming solves each subproblem only once and stores the solution for subsequent lookup. A recursive algorithm would instead revisit and solve the same problems several times. Hence, a divide-and-conquer approach should be used when new problems are generated at each step of the recursion. Consider matrix-chain multiplication for n = :,,,,,,,,,,,,,,,,,,, A top-down recursive algorithm would visit all nodes of the tree, which is exponential in n. A bottom-up dynamic programming algorithm will only solve the Θ(n ) different subproblems. Optimal polygon triangulation We consider convex polygons P defined by a sequence of vertices v 0,v,,v n where the straightline segments between consecutive vertices, called sides, form the boundary of P. Convexity means that any segment between two vertices will not go outside P. If a segment goes between two non-adjacent vertices of P it is called a chord. We also define a weight function w for triangles formed by sides and chords of P. The problem is to find a triangulation that minimizes the sum of the weights of the triangles. A natural weight function is the sum of the side lengths in a triangle: w( v i v j v k ) = v i v j + v j v k + v k v i But the algorithm below works for an arbitrary weight function. There is a correspondence with the matrix-chain problem. The paranteses which give the multiplication order can be seen as a binary tree, called a parse tree of the expression. A triangulation of a polygon with n sides uniquely corresponds to such a tree with n leaves. A triangulation and corresponding parse tree for (A A )(A (A A 5 )):

5 v A v0 root v5 A v A v A A5 v A A A A A5 Which triangulation of the polygon in the figure corresponds to A (((A A )A )A 5 )? A small change in the algorithm that computes the best multiplication order gives an algorithm for computing the optimal triangulation. Let t[i,j] be the weight of an optimal triangulation of the polygon v i,,v j. Put w( v i,v i ) = 0, for degenerated polygons which only consist of one side. Recursively we have: t[i,j] = 0 if i = j min i k<j (t[i,k] + t[k +,j] + w( v i v k v j )) if i < j We are looking for a vertex v k such that the weight of the triangle v i v k v j plus the triangulations of v i,,v k and v k,,v j is minimized. As for matrix multiplication an optimal triangulation is found in O(n ) time and O(n ) space. Consider: v0 v7 t[,] v v6 t[5,7] v v v v5 To triangulate the four-sided polygon v,v 5,v 6,v 7 there are two alternatives: k = 5 t[5,7] = t[5,5] + t[6,7] + w( v v 5 v 7 ) k = 6 t[5,7] = t[5,6] + t[7,7] + w( v v 6 v 7 ) If the distance from v to v 6 is greater than the distance from v 5 to v 7, k = 5 is chosen. For a polygon with only three vertices, v 0,v,v, we get t[,] = t[,]+t[,]+w( v 0 v v ), i.e. the sum of the side lengths of the triangle. 5