Dynamic Programming. Applications. Applications. Applications. Algorithm Design 6.1, 6.2, 6.3

Transcription

1 Set of weighted intervals with start and finishing times Goal: find maimum weight subset of non-overlapping intervals Dnamic Programming Algorithm Design.,.,. j j j j8 Given n points in the plane find a small sequence of lines that minimizes the squared error. Sequence alignment Given two strings A and B how man edits (insertions, deletions, relabelings) is needed to turn A into B? A C A A G T C - C A T G T - A C A A - G T C - C A - T G T - mismatch, gaps mismatches, gaps

2 RNA Secondar structure Sequence alignment Shortest paths with negative weights Given a weighted graph, where edge weights can be negative, find the shortest path between two given vertices. s t RNA Secondar structure Sequence alignment Shortest paths with negative weights Some other famous applications Uni diff for comparing files Vovke-Kasami-Younger for parsing contet-free grammars Viterbi for hidden Markov models. Dnamic Programming Greed. Build solution incrementall, optimizing some local criterion. Divide-and-conquer. Break up problem into independent subproblems, solve each subproblem, and combine to get solution to original problem. Dnamic programming. Break up problem into overlapping subproblems, and build up solutions to larger and larger subproblems. Can be used when the problem have optimal substructure : Solution can be constructed from optimal solutions to subproblems Use dnamic programming when subproblems overlap. Weighted Interval Scheduling 8

3 problem n jobs (intervals) Job i starts at si, finishes at fi and has weight/value vi. Goal: Find maimum weight subset of non-overlapping (compatible) jobs. Label/sort jobs b finishing time: f f fn j j j j8 9 Label/sort jobs b finishing time: f f fn p(j) = largest inde i < j such that job i is compatible with j. Label/sort jobs b finishing time: f f fn p(j) = largest inde i < j such that job i is compatible with j. j j j j8 j j j j8 p() = p() = p() = p() = p() = p() = p() = p(8) =

4 Label/sort jobs b finishing time: f f fn p(j) = largest inde i < j such that job i is compatible with j. Optimal solution OPT: Case. OPT selects last job OPT = vn + optimal solution to subproblem on,,p(n) Case. OPT does not select last job OPT = optimal solution to subproblem on,,n OPT(j) = value of optimal solution to the problem consisting job requests,,..,j. Case. OPT(j) selects job j OPT(j) = vj + optimal solution to subproblem on,,p(j) Case. OPT(j) does not job j OPT = optimal solution to subproblem, j- j p() = p() = Recursion: j p() = p() = p() = OPT( j) = { ma{v j + OPT(p( j)), OPT( j )} otherwise p() = j p() = j8 p(8) = : brute force : brute force OPT( j) = { ma{v j + OPT(p( j)), OPT( j )} otherwise OPT( j) = { ma{v j + OPT(p( j)), OPT( j )} otherwise Input: n, s[..n], f[..n], v[..n] Input: n, s[..n], f[..n], v[..n] Sort jobs b finish time so that f[] f[] f[n] Compute p[], p[],, p[n] Compute-Brute-Force-Opt(j) if j = return return ma(v[j] + Compute-Brute-Force-Opt(p[j]), Compute-Brute-Force-Opt(j-)) Sort jobs b finish time so that f[] f[] f[n] Compute p[], p[],, p[n] Compute-Brute-Force-Opt(j) if j = return return ma(v[j] + Compute-Brute-Force-Opt(p[j]), Compute-Brute-Force-Opt(j-)) time Θ(^n)

5 : brute force : brute force OPT( j) = { ma{v j + OPT(p( j)), OPT( j )} otherwise OPT( j) = { ma{v j + OPT(p( j)), OPT( j )} otherwise Input: n, s[..n], f[..n], v[..n] Input: n, s[..n], f[..n], v[..n] Sort jobs b finish time so that f[] f[] f[n] Compute p[], p[],, p[n] Compute-Brute-Force-Opt(j) if j = return return ma(v[j] + Compute-Brute-Force-Opt(p[j]), Compute-Brute-Force-Opt(j-)) time Θ(^n) Sort jobs b finish time so that f[] f[] f[n] Compute p[], p[],, p[n] Compute-Brute-Force-Opt(j) if j = return return ma(v[j] + Compute-Brute-Force-Opt(p[j]), Compute-Brute-Force-Opt(j-)) time Θ(^n) Avoid recomputation? : memoization : memoization Input: n, s[..n], f[..n], v[..n] Sort jobs b finish time so that f[] f[] f[n] Compute p[], p[],, p[n] for j= to n M[j] = null M[] =. Compute-Memoized-Opt(j) if M[j] is empt M[j] = ma(v[j] + Compute-Memoized-Opt(p[j]), Compute-Memoized-Opt(j-)) return M[j] Input: n, s[..n], f[..n], v[..n] Sort jobs b finish time so that f[] f[] f[n] Compute p[], p[],, p[n] for j= to n M[j] = empt M[] =. Compute-Memoized-Opt(j) if M[j] is empt M[j] = ma(v[j] + Compute-Memoized-Opt(p[j]), Compute-Memoized-Opt(j-)) return M[j] j p() = p() = p() = i M[i] Running time O(n log n): j p() = 8 Sorting takes O(n log n) time. p() = Computing p(n): O(n log n) b using sort b start time Each subproblem solved once. Time to solve a subproblem constant. Space O(n) j j8 p() = p() = p(8) =

6 : bottom-up : bottom-up Compute-Bottom-Up Opt(n, s[..n], f[..n], v[..n]) Compute-Bottom-Up Opt(n, s[..n], f[..n], v[..n]) Sort jobs b finish time so that f[] f[] f[n] Compute p[], p[],, p[n] i M[i] Sort jobs b finish time so that f[] f[] f[n] Compute p[], p[],, p[n] M[] =. for j= to n M[j] = ma(v[j] + M(p[j]), M(j-)) return M[n] Running time O(n log n): Sorting takes O(n log n) time. Computing p(n): O(n log n) b using sort b start time For loop: O(n) time Each iteration takes constant time. M[] =. for j= to n M[j] = ma(v[j] + M(p[j]), M(j-)) return M[n] j j j p() = p() = p() = p() = p() = p() = p() = 8 Space O(n) j8 p(8) = 8 : finding solution DP algorithm returns value. How do we find the solution itself? Make a second pass: Find-Solution(j) if j= Return emptset if v[j] + M[p[j]] > M[j-] return {j} Find-Solution(p[j]) return Find-Solution(j-) Segmented Least Squares Analsis: #recursive calls n => O(n) time.

7 Least squares Least squares. Given n points in the plane: (,), (,),, (n,n). Find a line = a + b that minimizes the sum of the squared error: n SSE = ( i a i b) i= Segmented least squares Points lie roughl on a sequence of line segments. Given n points in the plane (,), (,),, (n,n). Find a sequence of lines that minimizes f(). What is a good choice for f() that balance accurac and number of lines? Solution. Calculus => minimum error is achieved when a = n i i i ( i i )( i i ), b = i i a i i n i i ( i i ) n Segmented least squares. Given n points in the plane (,), (,),, (n,n) and a constant c > find a sequence of lines that minimizes f() = E + cl: E = sum of sums of the squared errors in each segment. L = number of lines Dnamic programming: multiwa choice OPT(j) = minimum cost for points p, p,, pj. e(i,j) = minimum sum of squares for points pi, pi+,, pj. To compute OPT(j): Last segment uses points pi, pi+,, pj for some i. Cost = e(i,j) + c + OPT(i-).

8 Dnamic programming: multiwa choice OPT(j) = minimum cost for points p, p,, pj. e(i,j) = minimum sum of squares for points pi, pi+,, pj. To compute OPT(j): Last segment uses points pi, pi+,, pj for some i. Cost = e(i,j) + c + OPT(i-). OPT( j) = { min i j {e(i, j) + c + OPT(i )} otherwise Segmented least squares algorithm OPT( j) = { min i j {e(i, j) + c + OPT(i )} otherwise Segmented-least-squares(n, p, p,,pn,c) for j= to n for i= to j Compute the least squares e(i,j) for the segment pi, pi+,,pj. M[] =. for j= to n M[j] = for i= to j M[j] = min(m[j],e(i,j) + c + M[i-]) Return M[n] Segmented least squares algorithm Time. O(n ) for computing e(i,j) for O(n ) pairs (O(n) per pair). O(n ) for computing M. Total O(n ) Space O(n ). Segmented-least-squares(n, p, p,,pn,c) for j= to n for i= to j Compute the least squares e(i,j) for the segment pi, pi+,,pj. M[] =. for j= to n M[j] = for i= to j M[j] = min(m[j],e(i,j) + c + M[i-]) Return M[n]