Copyright 2000, Kevin Wayne 1

Size: px

Start display at page:

Florence McDonald
5 years ago
Views:

// lgorithmic Paradigms haptr Dynamic Programming rd. Build up a solution incrmntally, myopically optimizing som local critrion. Divid-and-conqur.

1 // lgorithmic Paradigms haptr Dynamic Programming rd. Build up a solution incrmntally, myopically optimizing som local critrion. Divid-and-conqur. Brak up a problm into two sub-problms, solv ach sub-problm indpndntly, and combin solution to sub-problms to form solution to original problm. Dynamic programming. Brak up a problm into a sris of ovrlapping sub-problms, and build up solutions to largr and largr sub-problms. Slids by Kvin Wayn. opyright Parson-ddison Wsly. ll rights rsrvd. Rundall Munro Dynamic Programming History Dynamic Programming pplications Bllman. Pionrd th systmatic study of dynamic programming in th 9s. Etymology. Dynamic programming = planning ovr tim. Scrtary of Dfns was hostil to mathmatical rsarch. Bllman sought an imprssiv nam to avoid confrontation. "it's impossibl to us dynamic in a pjorativ sns" "somthing not vn a ongrssman could objct to" Rfrnc: Bllman, R. E. Ey of th Hurrican, n utobiography. ras. Bioinformatics. ontrol thory. Information thory. Oprations rsarch. omputr scinc: thory, graphics, I, systms,. Som famous dynamic programming algorithms. Vitrbi for hiddn Markov modls. nix diff for comparing two fils. Smith-Watrman for squnc alignmnt. Bllman-Ford for shortst path routing in ntworks. ock-kasami-youngr for parsing contxt fr grammars. opyright, Kvin Wayn

2 // Wightd Intrval Schduling. Wightd Intrval Schduling Wightd intrval schduling problm. Job j starts at s j, finishs at f j, and has wight or valu v j. Two jobs compatibl if thy don't ovrlap. oal: find maximum wight subst of mutually compatibl jobs. a b c d f g 8 9 h Tim nwightd Intrval Schduling Rviw Wightd Intrval Schduling Rcall. rdy algorithm works if all wights ar. onsidr jobs in ascnding ordr of finish tim. dd job to subst if it is compatibl with prviously chosn jobs. Notation. Labl jobs by finishing tim: f f... f n. Df. p(j) = largst indx i < j such that job i is compatibl with j. Ex: p(8) =, p() =, p() =. Obsrvation. rdy algorithm can fail spctacularly if arbitrary wights ar allowd. wight = 999 b wight = a 8 9 Tim Tim 8 opyright, Kvin Wayn

3 // Dynamic Programming: Binary hoic Wightd Intrval Schduling: Brut Forc Notation. OPT(j) = valu of optimal solution to th problm consisting of job rqusts,,..., j. Brut forc algorithm. as : OPT slcts job j. can't us incompatibl jobs { p(j) +, p(j) +,..., j - must includ optimal solution to problm consisting of rmaining compatibl jobs,,..., p(j) optimal substructur as : OPT dos not slct job j. must includ optimal solution to problm consisting of rmaining compatibl jobs,,..., j- # if j = OPT( j) = $ % max v j + OPT( p( j)), OPT( j ) { othrwis Input: n, s,,s n, f,,f n, v,,v n Sort jobs by finish tims so that f f... f n. omput p(), p(),, p(n) omput-opt(j) { if (j = ) rturn ls rturn max(v j + omput-opt(p(j)), omput-opt(j-)) 9 Wightd Intrval Schduling: Brut Forc Wightd Intrval Schduling: Mmoization Obsrvation. Rcursiv algorithm fails spctacularly bcaus of rdundant sub-problms Þ xponntial algorithms. Mmoization. Stor rsults of ach sub-problm in a cach; lookup as ndd Ex. Numbr of rcursiv calls for family of "layrd" instancs grows lik Fibonacci squnc. Input: n, s,,s n, f,,f n, v,,v n Sort jobs by finish tims so that f f... f n. omput p(), p(),, p(n) p() =, p(j) = j- for j = to n M[j] = mpty global array M[j] = M-omput-Opt(j) { if (M[j] is mpty) M[j] = max(w j + M-omput-Opt(p(j)), M-omput-Opt(j-)) rturn M[j] opyright, Kvin Wayn

4 // Wightd Intrval Schduling: Running Tim laim. Mmoizd vrsion of algorithm taks O(n log n) tim. Sort by finish tim: O(n log n). omputing p( ) : O(n) aftr sorting by start tim. M-omput-Opt(j): ach invocation taks O() tim and ithr (i) rturns an xisting valu M[j] (ii) fills in on nw ntry M[j] and maks two rcursiv calls Progrss masur F = # nonmpty ntris of M[]. initially F =, throughout F n. (ii) incrass F by Þ at most n rcursiv calls. Ovrall running tim of M-omput-Opt(n) is O(n). Rmark. O(n) if jobs ar pr-sortd by start and finish tims. omputing th Indx p(.) in Linar Tim Intrval 8 Finish tim 8 9 Intrval 8 Start tim 8 Intrval 8 p(.) 8 Tim 8 9 Wightd Intrval Schduling: Finding a Solution Wightd Intrval Schduling: Bottom-p Q. Dynamic programming algorithms computs optimal valu. What if w want th solution itslf?. Do som post-procssing. Run M-omput-Opt(n) Run Find-Solution(n) Find-Solution(j) { if (j = ) output nothing ls if (v j + M[p(j)] > M[j-]) print j Find-Solution(p(j)) ls Find-Solution(j-) Bottom-up dynamic programming. nwind rcursion. Input: n, s,,s n, f,,f n, v,,v n Sort jobs by finish tims so that f f... f n. omput p(), p(),, p(n) Itrativ-omput-Opt { M[] = for j = to n M[j] = max(v j + M[p(j)], M[j-]) # of rcursiv calls n Þ O(n). opyright, Kvin Wayn

5 // utomatd Mmoization Midtrm utomatd mmoization. Many functional programming languags (.g., Lisp) hav built-in support for mmoization. Q. Why not in imprativ languags (.g., Java)? (dfun F (n) (if (<= n ) n (+ (F (- n )) (F (- n ))))) Lisp (fficint) static int F(int n) { if (n <= ) rturn n; ls rturn F(n-) + F(n-); F(9) Java (xponntial) F() F(8) Man:.8 (8%) Mdian: 8 (8%) F(8) F() F() F() F() F() F() F() F() F() F() F() 8 Sgmntd Last Squars. Sgmntd Last Squars Last squars. Foundational problm in statistic and numrical analysis. ivn n points in th plan: (x, y ), (x, y ),..., (x n, y n ). Find a lin y = ax + b that minimizs th sum of th squard rror: n SSE = ( y i ax i b) i= y x Solution. alculus Þ min rror is achivd whn a = n x i y i i ( i x i ) ( i y i ), b = n x i ( x i ) i i i y i a i x i n opyright, Kvin Wayn

6 // Sgmntd Last Squars Sgmntd Last Squars Sgmntd last squars. Points li roughly on a squnc of svral lin sgmnts. ivn n points in th plan (x, y ), (x, y ),..., (x n, y n ) with x < x <... < x n, find a squnc of lins that minimizs f(x). Q. What's a rasonabl choic for f(x) to balanc accuracy and parsimony? goodnss of fit Sgmntd last squars. Points li roughly on a squnc of svral lin sgmnts. ivn n points in th plan (x, y ), (x, y ),..., (x n, y n ) with x < x <... < x n, find a squnc of lins that minimizs: th sum of th sums of th squard rrors E in ach sgmnt th numbr of lins L Tradoff function: E + c L, for som constant c >. numbr of lins y y x x Dynamic Programming: Multiway hoic Sgmntd Last Squars: lgorithm Notation. OPT(j) = minimum cost for points p,., p i+,..., p j. (i, j) = minimum sum of squars for points p i, p i+,..., p j. To comput OPT(j): Last sgmnt uss points p i, p i+,..., p j for som i. ost = (i, j) + c + OPT(i-). INPT: n, p,,p N, c Sgmntd-Last-Squars() { M[] = for j = to n for i = to j comput th last squar rror ij th sgmnt p i,, p j for $ & if j = OPT( j) = % min { (i, j) + c + OPT(i ) othrwis '& i j for j = to n M[j] = min i j ( ij + c + M[i-]) rturn M[n] Running tim. O(n ). can b improvd to O(n ) by pr-computing various statistics Bottlnck = computing (i, j) for O(n ) pairs, O(n) pr pair using prvious formula. opyright, Kvin Wayn

7 // Knapsack Problm. Knapsack Problm Knapsack problm. ivn n objcts and a "knapsack." Itm i wighs w i > kilograms and has valu v i >. Knapsack has capacity of W kilograms. oal: fill knapsack so as to maximiz total valu. Ex: {, has valu. Itm Valu Wight W = 8 8 rdy: rpatdly add itm with maximum ratio v i / w i. Ex: {,, achivs only valu = Þ grdy not optimal. Dynamic Programming: Fals Start Dynamic Programming: dding a Nw Variabl Df. OPT(i) = max profit subst of itms,, i. as : OPT dos not slct itm i. OPT slcts bst of {,,, i- Df. OPT(i, w) = max profit subst of itms,, i with wight limit w. as : OPT dos not slct itm i. OPT slcts bst of {,,, i- using wight limit w as : OPT slcts itm i. accpting itm i dos not immdiatly imply that w will hav to rjct othr itms without knowing what othr itms wr slctd bfor i, w don't vn know if w hav nough room for i onclusion. Nd mor sub-problms! as : OPT slcts itm i. nw wight limit = w w i OPT slcts bst of {,,, i using this nw wight limit # if i = % OPT(i, w) = $ OPT(i, w) if w i > w % & max{ OPT(i, w), v i + OPT(i, w w i ) othrwis 8 opyright, Kvin Wayn

8 // Knapsack Problm: Bottom-p Knapsack lgorithm Knapsack. Fill up an n-by-w array W Input: n, w,,w n, v,,v n, W f for w = to W M[, w] = n + { {, for i = to n for w = to W if (w i > w) M[i, w] = M[i-, w] ls M[i, w] = max {M[i-, w], v i + M[i-, w-w i ] {,, {,,, {,,,, Itm 9 9 Valu Wight rturn M[n, W] OPT: {, valu = + 8 = W = Knapsack Problm: Running Tim Running tim. Q(n W). Not polynomial in input siz! "Psudo-polynomial." Dcision vrsion of Knapsack is NP-complt. [haptr 8]. Squnc lignmnt Knapsack approximation algorithm. Thr xists a polynomial algorithm that producs a fasibl solution that has valu within.% of optimum. [Sction.8] opyright, Kvin Wayn 8

9 // String Similarity Edit Distanc How similar ar two strings? ocurranc occurrnc o c u r r a n c - o c c u r r n c mismatchs, gap o c - u r r a n c pplications. Basis for nix diff. Spch rcognition. omputational biology. Edit distanc. [Lvnshtin 9, Ndlman-Wunsch 9] ap pnalty d; mismatch pnalty a pq. ost = sum of gap and mismatch pnaltis. o c c u r r n c mismatch, gap T T T - T T T o c - u r r - a n c T T T T - T T o c c u r r - n c mismatchs, gaps a T + a T + a + a d + a Squnc lignmnt Squnc lignmnt: Problm Structur oal: ivn two strings X = x x... x m and Y = y y... y n find alignmnt of minimum cost. Df. n alignmnt M is a st of ordrd pairs x i -y j such that ach itm occurs in at most on pair and no crossings. Df. Th pair x i -y j and x i' -y j' cross if i < i', but j > j'. cost( M ) = α xi y j + δ + δ (x i, y j ) M i : x!#" # $ i unmatchd j : y j unmatchd!### #" ##### $ mismatch Ex: T vs. TT. Sol: M = x -y, x -y, x -y, x -y, x -y. gap x x x x x x T - - T T Df. OPT(i, j) = min cost of aligning strings x x... x i and y y... y j. as : OPT matchs x i -y j. pay mismatch for x i -y j + min cost of aligning two strings x x... x i- and y y... y j- as a: OPT lavs x i unmatchd. pay gap for x i and min cost of aligning x x... x i- and y y... y j as b: OPT lavs y j unmatchd. pay gap for y j and min cost of aligning x x... x i and y y... y j- " jδ if i = $ " α xi y j + OPT(i, j ) $ $ OPT(i, j) = # min # δ + OPT(i, j) othrwis $ $ δ + OPT(i, j ) % % $ iδ if j = y y y y y y opyright, Kvin Wayn 9

10 // Squnc lignmnt: lgorithm Squnc lignmnt: lgorithm y Squnc-lignmnt(m, n, x x...x m, y y...y n, d, a) { for i = to m M[i, ] = id for j = to n M[, j] = jd for i = to m for j = to n M[i, j] = min(a[x i, y j ] + M[i-, j-], d + M[i-, j], d + M[i, j-]) rturn M[m, n] x m + n + f T T f T ap pnalty = Mismatch pnalty = x x x x x x nalysis. Q(mn) tim and spac. T - English words or sntncs: m, n. omputational biology: m = n =,. billions ops OK, but B array? - T T y y y y y y 8 RN Scondary Structur. RN Scondary Structur RN. String B = b b b n ovr alphabt {,,,. Scondary structur. RN is singl-strandd so it tnds to loop back and form bas pairs with itslf. This structur is ssntial for undrstanding bhavior of molcul. Ex: complmntary bas pairs: -, - opyright, Kvin Wayn

11 // RN Scondary Structur RN Scondary Structur: Exampls Scondary structur. st of pairs S = { (b i, b j ) that satisfy: Exampls. [Watson-rick.] S is a matching and ach pair in S is a Watson- rick complmnt: -, -, -, or -. [No sharp turns.] Th nds of ach pair ar sparatd by at last intrvning bass. If (b i, b j ) Î S, thn i < j -. [Non-crossing.] If (b i, b j ) and (b k, b l ) ar two pairs in S, thn w cannot hav i < k < j < l. bas pair Fr nrgy. sual hypothsis is that an RN molcul will form th scondary structur with th optimum total fr nrgy. approximat by numbr of bas pairs oal. ivn an RN molcul B = b b b n, find a scondary structur S that maximizs th numbr of bas pairs. ok sharp turn crossing RN Scondary Structur: Subproblms Dynamic Programming Ovr Intrvals First attmpt. OPT(j) = maximum numbr of bas pairs in a scondary structur of th substring b b b j. Notation. OPT(i, j) = maximum numbr of bas pairs in a scondary structur of th substring b i b i+ b j. match b t and b n as. If i ³ j -. OPT(i, j) = by no-sharp turns condition. as. Bas b j is not involvd in a pair. t n Difficulty. Rsults in two sub-problms. Finding scondary structur in: b b b t-. Finding scondary structur in: b t+ b t+ b n-. OPT(t-) nd mor sub-problms OPT(i, j) = OPT(i, j-) as. Bas b j pairs with b t for som i t < j -. non-crossing constraint dcoupls rsulting sub-problms OPT(i, j) = + max t { OPT(i, t-) + OPT(t+, j-) tak max ovr t such that i t < j- and b t and b j ar Watson-rick complmnts Rmark. Sam cor ida in KY algorithm to pars contxt-fr grammars. opyright, Kvin Wayn

12 // Bottom p Dynamic Programming Ovr Intrvals Dynamic Programming Summary Q. What ordr to solv th sub-problms?. Do shortst intrvals first. Rcip. haractriz structur of problm. Rcursivly dfin valu of optimal solution. omput valu of optimal solution. RN(b,,b n ) { for k =,,, n- for i =,,, n-k j = i + k omput M[i, j] rturn M[, n] using rcurrnc i 8 9 j onstruct optimal solution from computd information. Dynamic programming tchniqus. Binary choic: wightd intrval schduling. Multi-way choic: sgmntd last squars. dding a nw variabl: knapsack. Vitrbi algorithm for HMM also uss DP to optimiz a maximum liklihood tradoff btwn parsimony and accuracy Dynamic programming ovr intrvals: RN scondary structur. KY parsing algorithm for contxt-fr grammar has similar structur Running tim. O(n ). Top-down vs. bottom-up: diffrnt popl hav diffrnt intuitions. String Similarity. Squnc lignmnt How similar ar two strings? ocurranc occurrnc o c u r r a n c - o c c u r r n c mismatchs, gap o c - u r r a n c o c c u r r n c mismatch, gap o c - u r r - a n c o c c u r r - n c mismatchs, gaps 8 opyright, Kvin Wayn

13 // Edit Distanc Squnc lignmnt pplications. Basis for nix diff. Spch rcognition. omputational biology. Edit distanc. [Lvnshtin 9, Ndlman-Wunsch 9] ap pnalty d; mismatch pnalty a pq. ost = sum of gap and mismatch pnaltis. T T T - T T T oal: ivn two strings X = x x... x m and Y = y y... y n find alignmnt of minimum cost. Df. n alignmnt M is a st of ordrd pairs x i -y j such that ach itm occurs in at most on pair and no crossings. Df. Th pair x i -y j and x i' -y j' cross if i < i', but j > j'. cost( M ) = α xi y j + δ + δ (x i, y j ) M i : x!#" # $ i unmatchd j : y j unmatchd!### #" ##### $ mismatch gap T T T a T + a T + a + a T - T T d + a Ex: T vs. TT. Sol: M = x -y, x -y, x -y, x -y, x -y. x x x x x x T - - T T y y y y y y 9 Squnc lignmnt: Problm Structur Squnc lignmnt: lgorithm Df. OPT(i, j) = min cost of aligning strings x x... x i and y y... y j. as : OPT matchs x i -y j. pay mismatch for x i -y j + min cost of aligning two strings x x... x i- and y y... y j- as a: OPT lavs x i unmatchd. pay gap for x i and min cost of aligning x x... x i- and y y... y j as b: OPT lavs y j unmatchd. pay gap for y j and min cost of aligning x x... x i and y y... y j- " jδ if i = $ " α xi y j + OPT(i, j ) $ $ OPT(i, j) = # min # δ + OPT(i, j) othrwis $ $ δ + OPT(i, j ) % % $ iδ if j = Squnc-lignmnt(m, n, x x...x m, y y...y n, d, a) { for i = to m M[, i] = id for j = to n M[j, ] = jd for i = to m for j = to n M[i, j] = min(a[x i, y j ] + M[i-, j-], d + M[i-, j], d + M[i, j-]) rturn M[m, n] nalysis. Q(mn) tim and spac. English words or sntncs: m, n. omputational biology: m = n =,. billions ops OK, but B array? opyright, Kvin Wayn

14 // Squnc lignmnt: Linar Spac. Squnc lignmnt in Linar Spac Q. an w avoid using quadratic spac? Easy. Optimal valu in O(m + n) spac and O(mn) tim. omput OPT(i, ) from OPT(i-, ). No longr a simpl way to rcovr alignmnt itslf. Thorm. [Hirschbrg 9] Optimal alignmnt in O(m + n) spac and O(mn) tim. lvr combination of divid-and-conqur and dynamic programming. Inspird by ida of Savitch from complxity thory. Squnc lignmnt: Linar Spac Squnc lignmnt: Linar Spac Edit distanc graph. Lt f(i, j) b shortst path from (,) to (i, j). Obsrvation: f(i, j) = OPT(i, j). Edit distanc graph. Lt f(i, j) b shortst path from (,) to (i, j). an comput f (, j) for any j in O(mn) tim and O(m + n) spac. j y y y y y y y y y y y y - - x x α xi y j d x d i-j x i-j x m-n x m-n opyright, Kvin Wayn

15 // Squnc lignmnt: Linar Spac Squnc lignmnt: Linar Spac Edit distanc graph. Lt g(i, j) b shortst path from (i, j) to (m, n). an comput by rvrsing th dg orintations and invrting th rols of (, ) and (m, n) Edit distanc graph. Lt g(i, j) b shortst path from (i, j) to (m, n). an comput g(, j) for any j in O(mn) tim and O(m + n) spac. j y y y y y y y y y y y y - - x i-j d x i-j α xi y j x d x x m-n x m-n 8 Squnc lignmnt: Linar Spac Squnc lignmnt: Linar Spac Obsrvation. Th cost of th shortst path that uss (i, j) is f(i, j) + g(i, j). Obsrvation. lt q b an indx that minimizs f(q, n/) + g(q, n/). Thn, th shortst path from (, ) to (m, n) uss (q, n/). n / y y y y y y y y y y y y - - x i-j x i-j q x x x m-n x m-n 9 opyright, Kvin Wayn

16 // Squnc lignmnt: Linar Spac Squnc lignmnt: Running Tim nalysis Warmup Divid: find indx q that minimizs f(q, n/) + g(q, n/) using DP. lign x q and y n/. onqur: rcursivly comput optimal alignmnt in ach pic. Thorm. Lt T(m, n) = max running tim of algorithm on strings of lngth at most m and n. T(m, n) = O(mn log n). n / T(m, n) T(m, n/) + O(mn) T(m, n) = O(mn logn) y y y y y y - Rmark. nalysis is not tight bcaus two sub-problms ar of siz (q, n/) and (m - q, n/). In nxt slid, w sav log n factor. x i-j q x x m-n Squnc lignmnt: Running Tim nalysis Thorm. Lt T(m, n) = max running tim of algorithm on strings of lngth m and n. T(m, n) = O(mn). Pf. (by induction on n) O(mn) tim to comput f(, n/) and g (, n/) and find indx q. T(q, n/) + T(m - q, n/) tim for two rcursiv calls. hoos constant c so that: T(m, ) cm T(, n) cn T(m, n) cmn + T(q, n/) + T(m q, n/) Bas cass: m = or n =. Inductiv hypothsis: T(m, n) cmn. T ( m, n) = = T ( q, n / ) + T ( m q, n / ) + cmn cqn / + c( m q) n / + cmn cqn + cmn cqn + cmn cmn opyright, Kvin Wayn

Areas. ! Bioinformatics. ! Control theory. ! Information theory. ! Operations research. ! Computer science: theory, graphics, AI, systems,.

Areas. ! Bioinformatics. ! Control theory. ! Information theory. ! Operations research. ! Computer science: theory, graphics, AI, systems,. lgorithmic Paradigms hapter Dynamic Programming reed Build up a solution incrementally, myopically optimizing some local criterion Divide-and-conquer Break up a problem into two sub-problems, solve each