11 Divide-and-Conquer und Rekursionsgleichungen

Transkript

1 DIVIDE-AND-CONQUER UND REKURSIONSGLEICHUNGEN 11 Divide-ad-Coquer ud Rekursiosgleichuge Divide-ad-Coquer Problem aufteile i Teilprobleme Teilproblem (rekursiv) löse Lösuge der Teilprobleme zusammesetze Typische Beispiele: Biäre Suche, Meregesort, Quicksort Mergesort Mergesort(A[1,, ]){ 1 if (==1) oder (==0) retur A; B 1 = Mergesort (A[1,, ]); 3 B = Mergesort (A[ +1,, ]); // + 3 divide-schritte retur "Mischug vo B 1 ud B " //Mischug bilde, coquer-schritt } Aufrufbaum bei = Zweierpotez A[1,, ] A[1,, ] A[ + 1,, ] A[1,, ] A[ + 1,, ] A[+1,, 3] A[3 + 1,, ] A[1,] A[1] A[]

2 161 Tiefe: geau log Laufzeit: Blätter: O() Aufteile: beim m Elemete O(m) Zusammesetze vo -mal Damit isgesamt: Elemete: O(m) (Aufteile) O() O() (Mische) O( ) O( ) O( ) O( ) O(1) O(1) Für die Blätter: O(1) = O() Für das Aufteile: c + c + c + + c 1 + c + Wo soll das ede? Wir addiere i eier adere Reihefolge: 1 c +c + c 3 +c ( ) +c ( log +c ( ) }{{} -mal = log c = O( log) Ebeso für das Mische: O( log) Isgesamt O( log) + O() = O( log) Wichtig: Richtige Reihefolge beim Zusammeaddiere Bei Bäume oft stufeweise!

3 16 11 DIVIDE-AND-CONQUER UND REKURSIONSGLEICHUNGEN Die eigetliche Arbeit beim divide-ad-coquer geschieht im Aufteile ud im Zusammefüge Der Rest ist rekusiv Mergesort eifach bottom-up ohe Rekursio, da starrer Aufrufbaum A[1, ],A[3, ],,A[ 1,] Sortiere A[1,,],A[5,,8], Sortiere Auch O( log) Ebefalls Heapsort sortiert i O( log) Bubblesort, Isertio Sort, Selectio Sort O( ) 111 Algorithmus: Quicksort Eigabe: array A[1,, ] of geordeter Datetyp 1 if ( == m) retur a = ei A[i]; 3 Lösche A[i] aus A for j=1 to { 5 if (A[j] a){ A[j] als ächstes Elemet zu B 1 ; break; } 6 if (A[j] > a){ A[j] zu B } } 7 A = B 1 a B 8 if (B 1 Ø) Quicksort (B 1 ) // B 1 als Teil vo A 9 if (B Ø) Quicksort (B ) // B als Teil vo A Beachte: Die Prozedur Partitio aus dem 1 Semester erlaubt es, mit dem array A alleie auszukomme

4 111 Algorithmus: Quicksort 163 Prozedurbäume: O() O(1) O( ) O(1) 1 1 Hier O( log): O() + O( ) + O( ) + + O(1) + O() }{{} Blätter Aber auch: Hier kei Aufruf, we liks vo a ichts ist, B 1 = Ø O() -1 O( 1) - O( ) -3 O(1) 1 Laufzeit: ( 1) = = O( ) (Aufteile) = O() (Zusammesetze) Also: O( ) ud auch Ω( )

5 16 11 DIVIDE-AND-CONQUER UND REKURSIONSGLEICHUNGEN Wieso Quicksort trotzdem i der Praxis häufig? I der Regel tritt ei gutartiger Baum auf, ud wir habe O( log) Vergleiche immer mit festem a, a i eiem Register = schelleres Vergleiche Dagege sid beim Mische vo Mergesort öfter beide Elemete des Vergleiches eu Aufrufbaum vo Quicksort vorher icht zu erkee Keie icht-rekursive Implemetierug wie bei Mergesort Nur mit Hilfe eies (Rekursios-) Kellers Noch eimal zu Mergesort Wir betrachte de Fall, dass eie Zweierpotez ist, da,,,1 = 0 ebefalls Sei T() = worst-case-zeit bei A[1,,] Da gilt für ei geeigetes c: T() c + T( ) T(1) c Eimaliges Teile O() Mische O() Aufrufverwaltug hier O() Betrachte u T() = c + T( ) T(1) = c Da durch Abwickel der rekursive Gleichug: T() = c + T( ) = c + c + T( ) = c + c + c + T( 8 ) = c log + T(1) = c log + c = O(c log) = O( log) Schließlich och ei streger Iduktiosbeweis, dass (T() = O( log) Iduktiosafag: T(1) = O(1 log1) = 0! stimmt so icht Also fage wir bei T() a T() d für ei d geht

6 111 Algorithmus: Quicksort 165 Iduktiosschluss: T() = c + T( ) c + d c + d (log 1) = c + d log d d log geht, we c d gewählt ist Wie sieht das bei Quicksort aus? T() = worst-case-zeit vo Quicksort auf A[1,, ] Da T() c + T( 1) T() c + T(1) + T( ) T() c + T() + T( 3) T() c + T( ) + T(1) T() c + T( 1) Also T(1) c T() c + max({t( 1)} {T(i) + T( i 1) 1 i 1}) Da T() d für d geeiget Iduktiosafag: Idukstiosschluss: T() c + Max({d( 1) a } {d i + d( i 1) 1 i 1}) }{{} i+ i 1 1 c + d( 1) d für d c Aufgabe: Stelle Sie die Rekursiosgleichug für eie rekursive Versio der biäre Suche auf ud schätze sie diese bestmöglich ab

7 DIVIDE-AND-CONQUER UND REKURSIONSGLEICHUNGEN 11 Multiplikatio großer Zahle Im Folgede behadel wir das Problem der Multiplikatio großer Zahle Bisher habe wir ageomme: Zahle i ei Speicherwort = arithmetische Ausdrücke i O(1) Ma spricht vom uiforme Kostemaß Bei größere Zahle kommt es auf de Multiplikatiosalgorithmus a Ma misst die Laufzeit i Abhägigkeit vo der # Bits, die der Recher verarbeite muss Das ist bei eier Zahl etwa log (geauer für 1 log + 1) Ma misst icht i der Zahl selbst! Die ormale Methode, zwei Zahle zu addiere, lässt sich i O() Bitoperatioe implemetiere bei Zahle der Läge : a 1 a + b 1 b a + b Multiplikatio i O( ): (a 1 a ) (b 1 b ) = (a 1 a ) b 1 O() (a 1 a ) b O() (a 1 a ) b O() Summebildug 1 Additioe mit Zahle der Läge = O( )! Mit divide-ad-coquer geht es besser! Nehme wir zuächst eimal a, ist eie Zweierpotez Da a:= a 1 a = b 1 b b:= a := a 1 a = b 1 b b := a a := 1 a b 1 b b := Nu ist

8 11 Multiplikatio großer Zahle 167 a b = (a + a ) b + b a= = }{{} a }{{} b + }{{} a }{{} b + a b + a b b= Mit de Produkte rekursiv weiter Das Programm sieht i etwa so aus: Mult(a, b, ){ //a=a 1, a, b=b 1,, b } 1 if ( == 1) retur a b // Zweierpotez a, a, b, b wie obe // Divide 3 m 1 := Mult(a, b, /); m := Mult(a, b, /); 5 m 3 := Mult(a, b, /); 6 m := Mult(a, b, /); 7 retur (m 1 + (m +m 3 ) + m ) //Coquer Aufrufbaum, = : 1 1 Tiefe log Laufzeit? Bei Mult(a,b,) braucht der divide-schritt ud die Zeit für die Aufrufe selbst zusamme O() Der coquer-schritt erfolgt auch i O() Zähle wir wieder pro Stufe: 1 Stufe d (vo O()) Stufe d 3 Stufe d log te Stufe log 1 log d Blätter: log d

9 DIVIDE-AND-CONQUER UND REKURSIONSGLEICHUNGEN Das gibt: T() log i=0 = d i d i log i=0 i = d log k = O( ) mit x i = xk+1 1 x 1 i=0 für alle x 1 (x>0, x<0 egal!), geometrische Reihe Betrachte wir die iduzierte Rekursiosgleichug Aahme: = Zweierpotez (Beachte: log log +1, dh zwische ud existiert eie Zweierpotez) T(1) = d T() = d + T( ) Versuche T() = O( ) durch Iduktio zu zeige 1 Versuch: T() d Iduktiosafag: Iduktiosschluss: T() = d + T( ) d + d > d Iduktio geht icht! Müsse irgedwie das d uterbrige Versuch T() d gibt ei Iduktiosschluss T() d + d > d 3 Versuch T() d d Iduktiosafag: T(1) d d = d

10 11 Multiplikatio großer Zahle 169 Iduktiosschluss: T() = d + T( ) d + (d( d ) = d + d d = d d Vergleiche auch Seite 16, wo log = log 1 wichtig ist Nächstes Ziel: Verbesserug der Multiplikatio durch ur och drei rekursive Aufrufe mit jeweils viele Bits Aalysiere wir zuächst die Laufzeit = O() O() 1 Stufe = = = Stufe log divide-ad-coquer-schritte + Zeit a Blätter 1 Stufe d, Stufe 3 d, 3 Stufe 3 3 d,, log te Stufe Blätter 3 log d 1

11 DIVIDE-AND-CONQUER UND REKURSIONSGLEICHUNGEN Da ist T() = log i=0 3 i d i = d ( 3 )i = d (3 )log }{{} = 1 d 3 (3 )log = 3 d log ( 3 ) log <1 {}}{ log ( 3 = 3 d ) = 3 d log 3 = O( 159 ) Also tatsächlich besser als O( ) Fasse wir zusamme: Aufrufe mit, liearer Zusatzaufwad T() = d log i i=0 }{{} i =1 = O( log) (Auf jeder Stufe, dh Aufrufe, halbe Größe) 3 Aufrufe T() = d ( 3 )i = O(d log 3 ) (3 Aufrufe, halbe Größe) Aufrufe T() = d ( )i = d = O( ) ( Aufrufe, halbe Größe) Aufgabe: Stelle Sie für de Fall der drei Aufrufe die Rekursiosgleichuge auf ud beweise Sie T() = O( log 3 ) duch eie ordugsgemäße Iduktio

12 11 Multiplikatio großer Zahle 171 Zurück zur Multiplikatio a:= a 1 a = b:= b 1 b = a := a 1 a b := b 1 b a := a +1 a b := b +1 b Wie köe wir eie Aufruf eispare? Erlaube us zusätzliche Additioe: Wir beobachte zuächst allgemei: (x y) (u v) = x(u v) + y (u v) = x u x v + y u y v (eie explizite ud implizite Multiplikatioe (aber i Summe)) Wir versuche jetzt a b + a b auf eie Schlag zu ermittel: (a a ) (b b ) = a b a b + a b + a b Ud: a b,a b brauche wir sowieso ud a b + a b = (a a ) (b b ) + a b + a b Das Programm: m 1 = Mult(a, b, ) m 3 = Mult(a, b, ) if (a - a < 0, b -b < 0) m = Mult(a -a, b -b, )// a a, b b < 1 if (a - a 0, b -b < 0) retur (m 1 + (m + m 1 + m 3 ) + m 3 Zeit O( ) Damit für die Zeit T(1) d T() d + 3 T( ) O(log 3 ) Also Additio liear, icht bekat für Multiplikatio Wir gehe jetzt wieder davo aus, dass die Basisoperatioe i O(1) Zeit durchzuführe sid Erier wir us a die Matrizemultiplikatio: quadratische Matrize

13 17 11 DIVIDE-AND-CONQUER UND REKURSIONSGLEICHUNGEN ( a11 a 1 a 1 a ) ( b11 b 1 b 1 b ) ( a11 b = 11 + a 1 b 1 a 11 b 1 + a 1 b a 1 b 11 + a b 1 a 1 b 1 + a b ) ud allgemei habe wir bei -Matrize: a 11 a 1 b 11 b 1 a 1 a b 1 b = i=1 a 1ib i1 i=1 a 1ib i i=1 a ib i1 i=1 a 1ib i i=1 a ib i Laufzeit ist, pro Eitrag des Ergebisses: Multiplikatioe, 1 Additioe, also O() Bei Eiträge O( 3 )(= O( ) 3 ) Überrasched war seierzeit, dass es besser geht mit divide-ad-coquer Wie köte ei divide-ad-coquer-asatz fuktioiere? Teile wir die Matrize eimal auf: a 11 a 1 a 1 a = ( A11 A 1 A 1 A ) a 1 a A i,j sid - Matrize (wir ehme wieder a, -er-potez) b 11 b 1 b 1 b = ( B11 B 1 B 1 B ) i=1 a 1ib i1 i=1 a ib i1 i=1 a 1ib i i=1 a ib i = ( C11 C 1 C 1 C ) Es ist

14 11 Multiplikatio großer Zahle 173 C 1 1 = i=1 a 1ib i1 i=1 a i b i1 i=1 a 1ib i i=1 a i b i Es ist A 11 B 11 = i=1 a 1ib i1 i=1 a i b i1 i=1 a 1ib i i=1 a i b i