CMPS 2200 Fall Dynamic Programming. Carola Wenk. Slides courtesy of Charles Leiserson with changes and additions by Carola Wenk

Transcription

1 CMPS 00 Fall 04 Dynamic Programming Carola Wenk Slides courtesy of Charles Leiserson with changes and additions by Carola Wenk 9/30/4 CMPS 00 Intro. to Algorithms

2 Dynamic programming Algorithm design technique A technique for solving problems that have. an optimal substructure property (recursion). overlapping subproblems Idea: Do not repeatedly solve the same subproblems, but solve them only once and store the solutions in a dynamic programming table 9/30/4 CMPS 00 Intro. to Algorithms

3 Example: Fibonacci numbers F(0)=0; F()=; F(n)=F(n-)+F(n-) for n 0,,,, 3, 5, 8, 3,, 34, 55, 89, Dynamic-programming hallmark # Optimal substructure An optimal solution to a problem (instance) contains optimal solutions to subproblems. Recursion 9/30/4 CMPS 00 Intro. to Algorithms 3

4 Example: Fibonacci numbers F(0)=0; F()=; F(n)=F(n-)+F(n-) for n Implement this recursion directly: n F(n) F(n-) F(n-) n/ same subproblem F(n-) F(n-3) F(n-3) F(n-4) F(n-3) F(n-4)F(n-4) F(n-5) F(n-4) F(n-5)F(n-5) F(n-6) Runtime is exponential: n/ T(n) n But we are repeatedly solving the same subproblems 9/30/4 CMPS 00 Intro. to Algorithms 4

5 Dynamic-programming hallmark # Overlapping subproblems A recursive solution contains a small number of distinct subproblems repeated many times. The number of distinct Fibonacci subproblems is only n. 9/30/4 CMPS 00 Intro. to Algorithms 5

6 Dynamic-programming There are two variants of dynamic programming:. Bottom-up dynamic programming (often referred to as dynamic programming ). Memoization 9/30/4 CMPS 00 Intro. to Algorithms 6

7 Bottom-up dynamicprogramming algorithm Store D DP-table and fill bottom-up: F: fibbottomupdp(n) F[0] 0 F[] for (i, i n, i++) F[i] F[i-]+F[i-] return F[n] Time = (n), space = (n) 9/30/4 CMPS 00 Intro. to Algorithms 7

8 Memoization algorithm Memoization: Use recursive algorithm. After computing a solution to a subproblem, store it in a table. Subsequent calls check the table to avoid redoing work. fibmemoization(n) for all i: F[i] = null fibmemoizationrec(n,f) return F[n] fibmemoizationrec(n,f) if (F[n]= null) if (n=0) F[n] 0 if (n=) F[n] F[n] fibmemoizationrec(n-,f) + fibmemoizationrec(n-,f) return F[n] Time = (n), space = (n) 9/30/4 CMPS 00 Intro. to Algorithms 8

9 Longest Common Subsequence Example: Longest Common Subsequence (LCS) Given two sequences x[.. m] and y[.. n], find a longest subsequence common to them both. a not the x: A B C B D A B y: B D C A B A BCBA = LCS(x, y) functional notation, but not a function 9/30/4 CMPS 00 Intro. to Algorithms 9

10 Brute-force LCS algorithm Check every subsequence of x[.. m] to see if it is also a subsequence of y[.. n]. Analysis m subsequences of x (each bit-vector of length m determines a distinct subsequence of x). Hence, the runtime would be exponential! 9/30/4 CMPS 00 Intro. to Algorithms 0

11 Towards a better algorithm Two-Step Approach:. Look at the length of a longest-common subsequence.. Extend the algorithm to find the LCS itself. Notation: Denote the length of a sequence s by s. Strategy: Consider prefixes of x and y. Define c[i, j] = LCS(x[.. i], y[.. j]). Then, c[m, n] = LCS(x, y). 9/30/4 CMPS 00 Intro. to Algorithms

12 Theorem. c[i, j] = Recursive formulation Proof. Case x[i] = y[j]: x: y: c[i, j ] + if x[i] = y[j], max{c[i, j], c[i, j ]} otherwise. i m = Let z[.. k]=lcs(x[.. i], y[.. j]), where c[i, j] = k. Then, z[k] = x[i], or else z could be extended. Thus, z[.. k ] is CS of x[.. i ] and y[.. j ]. 9/30/4 CMPS 00 Intro. to Algorithms... j n...

13 Proof (continued) Claim: z[.. k ] = LCS(x[.. i ], y[.. j ]). Suppose w is a longer CS of x[.. i ] and y[.. j ], that is, w > k. Then, cut and paste: w z[k] (w concatenated with z[k]) is a common subsequence of x[.. i] and y[.. j] with w z[k] > k. Contradiction, proving the claim. Thus, c[i, j ] = k, which implies that c[i, j] = c[i, j ] +. Other cases are similar. 9/30/4 CMPS 00 Intro. to Algorithms 3

14 Dynamic-programming hallmark # Optimal substructure An optimal solution to a problem (instance) contains optimal solutions to subproblems. Recursion If z = LCS(x, y), then any prefix of z is an LCS of a prefix of x and a prefix of y. 9/30/4 CMPS 00 Intro. to Algorithms 4

15 Recursive algorithm for LCS LCS(x, y, i, j) if (i=0 or j=0) c[i, j] 0 else if x[i] = y[ j] c[i, j] LCS(x, y, i, j ) + else c[i, j] max{lcs(x, y, i, j), LCS(x, y, i, j )} return c[i, j] Worst-case: x[i] y[ j], in which case the algorithm evaluates two subproblems, each with only one parameter decremented. 9/30/4 CMPS 00 Intro. to Algorithms 5

16 Recursion tree m = 3, n = 4: 3,4,4,4,3 same subproblem,3 3,3 3, m+n,3,,3, Height = m + n work potentially exponential., but we re solving subproblems already solved! 9/30/4 CMPS 00 Intro. to Algorithms 6

17 Dynamic-programming hallmark # Overlapping subproblems A recursive solution contains a small number of distinct subproblems repeated many times. The distinct LCS subproblems are all the pairs (i,j). The number of such pairs for two strings of lengths m and n is only mn. 9/30/4 CMPS 00 Intro. to Algorithms 7

18 Memoization algorithm Memoization: After computing a solution to a subproblem, store it in a table. Subsequent calls check the table to avoid redoing work. LCS(x, y, i, j) if c[i, j] = NIL if (i=0 or j=0) c[i, j] 0 else if x[i] = y[ j] c[i, j] LCS(x, y, i, j ) + else c[i, j] max{lcs(x, y, i, j), LCS(x, y, i, j )} return c[i, j] Space = time = (mn); constant work per table entry. same as before 9/30/4 CMPS 00 Intro. to Algorithms 8

19 Recursive formulation c[i, j] = c[i, j ] + if x[i] = y[j], max{c[i, j], c[i, j ]} otherwise. c: j- j i- i c[i,j] 9/30/4 CMPS 00 Intro. to Algorithms 9

20 Bottom-up dynamicprogramming algorithm IDEA: Compute the table bottom-up. Time = (mn). y B D x A B C B D A B C 0 0 A B A /30/4 CMPS 00 Intro. to Algorithms 0

21 Bottom-up dynamicprogramming algorithm IDEA: Compute the table bottom-up. Time = (mn). Reconstruct LCS by backtracking. Space = (mn). Exercise: O(min{m, n}). y B x 0 A B C B D A B D C A B A /30/4 CMPS 00 Intro. to Algorithms