Algorithms and Architectures I Rasmus Løvenstein Olsen (RLO) Mm2: Rekursive algoritmer og rekurrens - October 12, 2010

Algorithms and Architectures I Rasmus Løvenstein Olsen (RLO) Mm2: Rekursive algoritmer og rekurrens - October 12, 2010 1

Algorithms and Architectures II 1. Introduction to analysis and design of algorithms (RLO - 11/10) 2. Recursive algorithms and recurrences (RLO - 12/10) 3. Implementation of recursive algorithms (Self study - 25/10) 4. Greedy algorithms, backtracking and recurrences (Self study - 26/10) 5. Sorting algorithms (RLO - 1/11) 6. Implementation of sorting algorithms (Self study - 2/11) 7. Counting, probabilities and randomized algorithms (RLO - 8/11) 8. Hash tables and Hashing (RLO - 10/11) 9. Binary search trees, red-black trees and string matching (RLO - 15/11) 10. Course round-up (RLO - 16/11) 2

Dagsorden Introduktion til rekursion og rekursive algoritmer Divide and conquer taktikken Eksempler på rekursive algoritmer Merge sort algoritmen Fibonaccis tal Hanois tårne Factoriale tal. Substitutionsmetoden Generelt om rekursive algoritmer Opsummering og konklusion Opgaver 3

Hanois tårne Du må kun flytte en ring ad gangen På hver eneste pind må der aldrig være en større ring på en mindre Spørgsmål: Hvordan ser algoritmen ud? Hvor lang tid tager det? 4

Algoritme til løsning af Hanois tårne Hvis n>1 så benyt denne procedure til at flytte n-1 skiver fra A til B Flyt største skive, n fra A til C. Hvis n>1 så benyt denne procedure til at flytte n-1 skiver fra B til C A B C NB: Angivelserne A, B, C er ikke faste angivelser 5

Fibonacci tal Fibonacci s tal først beskrevet af Leonardo da Pisa Tal udviklingen er beskrevet således at 3 5 2 1 1 8 F = 1, F = 1 1 2 F n = Fn + F 2; n 1 n 3 6

Merge-sort algoritmen Baserer sig på merge algoritmen vi så på sidste gang Men lad os lige genopfriske hvordan den så ud før vi ser på hvordan vi kan sortere med den vha. rekursivitet 7

Merge algoritmen grafisk representation 2 4 5 7 1 2 3 6 L 2 4 5 7 1 2 3 6 R 1 4 5 7 1 2 3 6 8 8 1 2 5 7 1 2 3 6 L 2 4 5 7 8 1 2 3 6 8 R L 2 4 5 7 8 1 2 3 6 8 R 1 2 2 7 1 2 3 6 L 2 4 5 7 8 1 2 3 6 8 R 8

Merge algoritmen Merge(A, p, q, r) 1 n1 = q-p+1 10 i=1 2 n2 = r-q 11 j=1 3 Make arrays L[1..n1+1], R[1..n2+1] 12 for k = p to r 4 for i = 1 to n1 13 do if L[i] R[j] 5 do L[i] = A[p+i-1] 14 then A[k] = L[i] 6 for j = 1 to n2 15 i = i+1 7 do R[j] = A[q+j] 16 else 8 L[n1+1] = Inf 17 j=j+1 9 R[n2+1] = Inf Θ(1) Θ(n) Θ(n) Θ(1) Θ(1) Θ(n) T(n) = Θ(1) + Θ(n) + Θ(n) + Θ(1) + Θ(1) + Θ(n) = Θ(n) 9

Merge-sort algoritmen grafisk representation Merge-sort Merge-sort 1 2 2 3 4 5 6 7 2 4 5 7 1 2 3 6 Merge-sort 2 5 4 7 1 3 2 6 5 2 4 7 1 3 2 6 Talrække (input) 10

Merge-sort Merge-sort(A,p,r) Cost Tid 1 if p<r c 1 Θ(1) 2 then q=(p+r)/2 c 2 Θ(1) 3 Merge-Sort(A,p,q) c 3 T(n/2) 4 Merge-Sort(A,q+1,r) c 4 T(n/2) 5 Merge(A,p,q,r) c 5 Θ(n) p = start af array r = slut af array 11

Kompleksitet af merge sort algoritmen Tidskompleksiteten bliver følgelig T ( n) Θ(1) = 2T ( n / 2) + Θ( n) ; n ; n = 1 > 1 Kan også skrives som Men hvorfor det sidste? T ( n) = Θ( n log2( n)) 12

Rekurens træ cn cn cn/2 cn/2 cn cn/4 cn/4 cn/4 cn/4 cn Log 2 (n) c c c c c c c c n cn Husk at vi her antager at opgaverne kommer som n = 2 k 13

Substitutions metoden Kan kun anvendes på simplere algoritmer hvor vi er i stand til at gætte en løsning, eller løsningsstruktur Metoden baserer sig på at udnytte gættet til at vise løsningen Metoden består af to trin 1. Gæt en form af løsningen 2. Brug af matematisk induktion til at finde konstanter og vis at løsningen virker 15

Eksempel med gætte metoden Bestem øvre eller nedre grænse for en rekurrent algoritme med kompleksitet Et gæt vil være T(n) = O(nlog 2 (n)) Metoden går nu ud på at bevise T(n) cnlog 2 (n) Men er det nu alt? T ( n) = 2T ( n / 2) + n 16

Nogle potentielle problemer. Ved induktiv bevisførelse skal vi nu vise løsningen holder Først finder vi et startspunkt, f.eks. n 0 = 1 Med T(1) =1 som den grænsende funktion får vi T(n=1) cnlog 2 (n) = clog 2 (1) = 0 Men 1 0!!! Så n 0 = 1 er ikke en god basis for bevis Men hvis vi vælger et n n 0 > 1, f.eks. n = 2 og n = 3 Dermed får vi følgende krav til konstanten c T(2) = 4 2cLog 2 (2) T(3) = 5 3cLog 2 (3) Dvs. at c 2 17

Alternative gæt Hvad nu hvis vi har noget der ligner noget vi kender.? T ( n) = 2T ( n / 2 + k) + n Konklusion: Hvis vi kan omformulere et problem til noget vi kender, kan vi også nemmere sige noget om dets kompleksitet 18

Et andet eksempel Eksempel Et gæt kunne være løsning O(n) Så vi prøver at vise T(n) cn med et passende valg af c Konklusion: Med passende valg af funktion og konstanter kan vi vise at T(n) cn - b, istedet for og vi er alle glade Eller hvad?... T( n) = T( n/ 2) + T( n/ 2) + 1 19

Vær opmærksom på algoritmen Antag vores tidligere kompleksitet T ( n) = 2T ( n / 2) + n Hvad nu hvis vi gætter at T(n) cn, dvs. T(n) = O(n)? Konklusion: Vær opmærksom på hvad i ved om algoritmen. Vi kan ikke bare snyde os til en simplere algoritme. (men vi kan godt snyde os selv ) 20

Ændring af variable I nogle tilfælde ligner funktionen ikke helt, men alligevel lidt.. F.eks. T ( n) = 2T ( n) + log 2( n) Kan der gøres noget ved den så den ligner endnu mere? Prøv m = log 2 (n), og se bort fra afrundingsfunktionen T (2 Hvis vi nu siger at S(m) = T(2 m ), så får vi noget vi kender m m / 2 ) = 2T (2 ) + m S ( m) = 2T ( m / 2) + m Endelig kan vi også transformere kompleksiteten, således at T ( n) = T (2 m ) = O(Log = S( m) 2 ( n)log = O( mlog 2 (Log 2 2 ( n))) ( m)) 21

Ekspandering af rekurrens Vi starter igen med følgende kompleksitet Efter induktion kan vi nu se at T ( n) 2T ( n / 2) + c2n i i T ( n) 2 T ( n / 2 ) + ic Antag at n sker i 2 potens, såsom 2 k, dvs. n = 2 k k = Log 2 (n), så kan kompleksiteten også skrives som k T ( n) 2 T (1) + kc = c 2 n 2 n, T (1) T ( n) c1n + c2nlog2( n) 1 23

24 Mere generelt om den type kompleksitet Den generelle forskrift for kompleksiteten Antag at n = b k, dvs. n forekommer i potenser af k med base b Kan derfor også udskrives som en sum Note: For merge-sort algoritmen er a = b = 2, og d(n) = cn ) ( ) / ( ) ( 1 (1) n d b n at n T T + = = = + = 1 0 ) ( ) ( k j j k j k b d a a n T

Homogene og partikulære løsninger Homogene løsning Homogene løsning T ( n) = a k k 1 j= 0 k j Udtrykker prisen for at løse et delproblem Eksakt løsning når d(n)=0 for alle n Partikulære løsning Udtrykker prisen for at danne og kombinere delproblemerne Hvis homogene løsning er større end partikulære løsning, så vokser kompleksiteten i samme grad som den homogene løsning Hvis den partikulære løsning vokser med mere end n ε for ε>0, så vokser den partikulære løsning med graden af d(n) Hvis d(n) vokser med samme hastighed som den homogene løsning, eller med maksimalt log k (n), så vokser den partikulære løsning med log(n) x d(n) + a j d( b Partikulære løsning ) 25

Nogle flere gode råd som konsekvens Hvis den homogene løsning er størst vil en hurtigere måde at kombinere delproblemerne praktisk taget ingen effekt have. Derfor bør man således finde en måde at dele problemet i endnu mindre problemer, der hurtigere kan løses Hvis den partikulære løsning er størst vil en formindskelse i kompleksiteten af at splitte og/eller kombinere delproblemer have størst effekt. For eksempel vil en reducering i kompleksitet af den del af algoritmen der opdeler arrayet A i merge-sort til en nær lineær funktion, f.eks. d(n)=cn 0.9, helt sikkert reducere den samlede kompleksitet. NB: Der gemmer sig nok en nobel pris eller lignende til den der kan opdage en merge algoritme med en sådan kompleksitet!! 26

Kogebog for multiplikative funktioner En funktion er benævnt multiplikativ hvis f(xy) = f(x)f(y) T (1) = 1 T ( n) = at ( n / b) + d( n) Overvej k a d( b) a 1 d( b) k 1 j k j a d( b ) = j= 0 1. a > d(b): giver at den partikulære og homogene løsning er ens, fordi (1) bliver O(a k ) ~ O(n logb(a) ). I det tilfælde afhænger kompleksiteten mest af hvorledes problemet bliver opdelt, og ikke så meget af løsningen. 2. a = d(b): bliver udtrykket O(n Logb(d(b)) Log b (n)) og i tilfældet med d(n)=n α, bliver det til O(n α Log b (n)) 3. a < d(b): giver at den partikulære løsning dominerer, og dermed O(d(b) k ) ~ O(n logb(d(b)) ). I det tilfælde give det mening at se på at minimere d(n) og/eller a og b. Et specialtilfælde hvor d(n)=n α, giver en løsning O(n α ) eller O(d(n)) k (1) 27

Nogle eksempler #1 Sammenlign de følgende kompleksiteter, med T(1)=1 1. T(n) = 4T(n/2) + n 2. T(n) = 4T(n/2) + n 2 3. T(n) = 4T(n/2) + n 3 T (1) = 1 T ( n) = at ( n / b) + d( n) I alle tre tilfælde gælder følgende: a = 4 b = 2 Den homogene løsning er n 2 pga. antagelsen om n = b k k = log b (n) gør at a k = a logb(n) = n logb(a) Log 2 (4) = 2 giver et n 2 28

Nogle eksempler #2 For 1) T(n) = 4T(n/2) + n: d(n) = n betyder at d(b=2) = 2 Fordi a = 4 > d(b=2), er løsningen n 2, dvs. T(n) er O(n 2 ) For 2) T(n) = 4T(n/2) + n 2 : d(n) = n 2, hvilket betyder at d(b=2) = 4 Fordi a = 4 = d(b=2), er løsningen n Logb(d(b)) Log b (n)=n 2 Log 2 (n) For 3) T(n)= 4T(n/2) + n 3 : d(n) = n 3, hvilket betyder at d(b=2) = 8 Fordi a = 4 < d(b=2), er løsningen af O(n Logb(d(b)) ) = O(n 3 ) 29

Andre funktioner Eksempel T(1) = 1 T(n) = 3T(n/2)+2n 1.5 2n 1.5 er ikke multiplikativ, men n 1.5 er! Prøv derfor med U(n) = T(n)/2 for alle n U(1) = ½ U(n) = 3U(n/2)+n 1.5 Hvis U(1) var 1, ville løsningen være n log2(3) <n 1.59 Vi kan nu vise at U(1) = ½ er mindre end n 1.59 /2, dermed O(n 1.59 ) Fordi d(b) = b 1.5 = 2.83 < a er løsningen O(a k ) = O(n 1.59 ) (a k = n Logb(a) ) 30

Et andet eksempel Betragt T(1) = 1 T(n) = 2T(n/2) + nlog b (n) Homogen løsning er n, fordi a = b = 2 Problemet er d(n) = nlog b (n), derfor skal den partikulære løsning beregnes manuelt k 1 j= 0 a j d( b k j ) = = k 1 j= 0 2 k( k + 1) log(2 Løsningen er således at den partikulære er O(nLog 2 (n)), der er større end den homogene løsning, hvilket medfører at T(n) = O(nLog 2 (n)) 2 k 1 j 2 k j k j ) 31

Opsummering og konklusion på forelæsning Rekursive algoritmer bruges i forskellige situationer hvor samme principielle problem kan løses igen og igen Hanois tårne Fibonacci tal Merge-sort algoritme Vi så på kompleksiten af rekursive algoritmer af typen Θ(1) T ( n) = 2T ( n / 2) + Θ( n) ; n ; n = 1 > 1 Løsninger af denne type, baseret på Substitution med gæt Ændring af variable til noget der ligner tidligere Generel omskrivning og analyse af rekursive algoritmer Homogene og partikulære løsninger Omskrivninger til standard model 33

Og endnu en at gå hjem på http://xkcd.com/ 34

Opgaver Opgaver fra Cormen (2nd edition) Opgave 4.1-1, 4.1-2, 4.1-3 Opgaver fra Comen (3rd edition) Opgave 4.3-2, 4.3-3, 4.3-4 Opgaver fra Aho, Hopcroft og Ullman Opgave 9.1, 9.2, 9.3, 9.4 36