Datenstrukturen & Algorithmen Lösungen zu Blatt 2 FS 12

Transkript

1 Eidgenössische Technische Hochschule Zürich Ecole polytechnique fédérle de Zurich Politecnico federle di Zurigo Federl Institute of Technology t Zurich Institut für Theoretische Informtik 29 Ferur 2012 Peter Widmyer Ynn Disser Dtenstrukturen & Algorithmen Lösungen zu Bltt 2 FS 12 Lösung 21 Rekursionsgleichungen Mit Teleskopieren kommt mn uf folgende Vermutung: Wir unterscheiden drei Fälle: T (n) = log (n) e + cn, 1 : Dnn wird unsere Vermutung zu: T (n) = log (n) e + cn log (n) 1 i=0 ( ( ) log i (n) 1 + d i=0 i + d log(n) Induktionsnfng: Die Vermutung stimmt für n = 1, denn T (1) = 0 e + c 0 + d 0 = e Induktionsnnhme: Wir nehmen n unsere Vermutung stimmt für T (n/), lso (es gilt log ( n ) = log (n) 1) T (n/) = log (n) 1 e + c n ( 1 + d log(n) 1 Induktionsschritt: Wir zeigen unter Verwendung der Induktionsnnhme, dss unsere Vermutung uch für T (n) = T (n/) + cn + d ( Ind Ann = log (n) 1 e + c n ( ) log ) (n) 1 + d log(n) 1 + cn + d = log (n) e + cn( + cn dlog(n) + + d = log (n) e + cn( + d log(n), = 1: Dnn wird unsere Vermutung zu: T (n) = e + cn ( d log (n) = d log (n) + c 1 n 1 + e Induktionsnfng: Die Vermutung stimmt für n = 1, denn T (1) = d log (1) + c e = e Induktionsnnhme: Wir nehmen n unsere Vermutung stimmt für T (n/), lso T (n/) = d log ( n ) + c1 n 1 + e

2 Induktionsschritt: Wir zeigen unter Verwendung der Induktionsnnhme, dss unsere Vermutung uch für =, ( 1) : Dnn wird unsere Vermutung zu: T (n) = T (n/) + cn + d Ind Ann = d log ( n ) + c1 n 1 + e + cn + d = d log (n) + c n 1 + cn + e = d log (n) + c n + n n 1 = d log (n) + c 1 n 1 + e T (n) = ne + cn log (n) + d n Induktionsnfng: Die Vermutung stimmt für n = 1, denn T (1) = 1 e + c d = e Induktionsnnhme: Wir nehmen n unsere Vermutung stimmt für T (n/), lso T (n/) = n n e + cn log (n/) + d Induktionsschritt: Wir zeigen unter Verwendung der Induktionsnnhme, dss unsere Vermutung uch für T (n) = T (n/) + cn + d ( Ind Ann n n = e + cn log (n/) + d ) + cn + d = ne + cn log (n) cn + cn + d n + = = ne + cn log (n) + d n Lösung 22 Asymptotische Lufzeit einschätzen ( Teil einer Klusurufge im Jnur 2012 ) Hier wr keine Begründung gefrgt Wir geen im folgenden dennoch die wesentlichen Argumente für die Lufzeit ) Die erste (äusserste) Schleife läuft genu n ml Für jede Itertion der ersten Schleife läuft die zweite log 2 n ml und für jede Itertion der zweiten Schleife läuft die dritte (innerste) n/10 ml Insgesmt ergit ds eine symptotische Lufzeit von Θ(n 2 log n) ) Die erste (äusserste) Schleife läuft genu n/2 ml Für jede Itertion der ersten Schleife läuft die zweite log3 n 2 = 2 log 3 n ml und die dritte n ml Insgesmt ergit ds eine symptotische Lufzeit von Θ(n log n + n n) = Θ(n n) + e c) Die äusserste Schleife läuft genu n/2 ml Im j-ten Durchluf der äusseren Schleife läuft die innere genu n 3 /j ml Die Gesmtzhl der Itertionen der inneren Schleife ist (die Hrmonische Reihe wächst logrithmisch) n/2 n 3 2i n/2 n 3 1 2i = n3 n/2 1 2 i = Θ(n3 log n) 2

3 Lösung 23 Vergleich von Sortierlgorithmen insertionsort selectionsort ulesort quicksort min mx min mx min mx min mx Vergleiche Θ(n) Θ(n 2 ) Θ(n 2 ) Θ(n 2 ) Θ(n 2 ) Θ(n 2 ) Θ(n log n) Θ(n 2 ) Eingefolge 1, 2,, n n, n,, 1 egl egl egl egl ( ) 1, 2,, n Vertuschungen 0 Θ(n 2 ) 0 Θ(n) 0 Θ(n 2 ) Θ(n) Θ(nlogn) Eingefolge 1, 2,, n n, n,, 1 1, 2,, n n, n,, 1 1, 2,, n n, n,, 1 1, 2,, n ( ) ( ): Eine entsprechende Folge ist nicht leicht hinzuschreien Die Folge muss so konstruiert sein, dss jedes Pivot den zu sortierenden Bereich hliert Für n = 7 wäre eine solche Folge: 4, 5, 7, 6, 2, 1, 3 Lösung 24 Algorithmenentwurf: divide-nd-conquer ) Mittels,,divide-nd-conquer kommt mn uf folgende Lösung: Wir teilen ds Arry in zwei möglichst gleich grosse Hälften (der Einfchheit hler nehmen wir n, n sei gerde) Die zentrle Beochtung ist nun: wenn in A[1n] ein Mehrheitselement existiert, lso mehr ls n/2 ml vorkommt, dnn muss genu dieses Element in einer der eiden Hälften mehr ls n/4 ml vorkommen! (Wenn es in eiden Hälften n/4 ml drin wäre, wäre es in A[1n] uch nur höchstens n/2 ml drin) Drus folgt, dss ds Mehrheitselement von A[1n] in mindestens einer der eiden Hälften eenflls ein Mehrheitselement ist, lso entweder von A[1n/2] oder von A[n/2+1n] Dieselen Üerlegungen funktionieren uch dnn, wenn n ungerde ist Wir estimmen dher einfch rekursiv in eiden Hälften ds Mehrheitselement, flls eines existiert Ddurch erhlten wir keinen, einen oder zwei,,kndidten (mögliche Elemente) für ds Mehrheitselement von A[1n] Für diese Kndidten prüfen wir einzeln, o sie ds Mehrheitselement von A[1n] sind, indem wir ds Arry einfch durchlufen und dei zählen, wie oft ein Kndidt vorkommt Anlyse: Sei T (n) die Lufzeit des Algorithmus für ein Arry mit n Elementen Dnn gilt lso: T (n) = 2T (n/2) + c n + d, und T (1) = e, woei c, d, e Konstnten sind Diese Rekursionsgleichung lässt sich mit Teleskopieren uflösen, oder indem mn die Lösung von Aufge 21 enutzt Mn erhält so T (n) = ne + cn log 2 (n) + d(n ) = Θ(n log n) Beispielcode: // r e t u r n s t h e m j o r i t y element or 1 i f none e x i s t s (we ssume A[ i ] >0) int m j o r i t y ( const vector <int>& A, int l, int r ) i f ( l == r ) return A[ l ] ; int m = l + ( l + r ) / 2 ; int cndidte1 = m j o r i t y ( l, m 1); int cndidte2 = m j o r i t y (m, r ) ; int count1 = 0, count2 = 0 ; i f (A[ i ] == cndidte1 ) ++count1 ; i f (A[ i ] == cndidte2 ) ++count2 ; int n = r l + 1 ; i f ( count1 > n /2) return cndidte1 ; else i f ( count2 > n /2) return cndidte2 ; else return 1; 3

4 ) Es ist möglich, ds Mehrheitselement in Linerzeit (dh O(n)) zu finden Ein Lösungsnstz ist wie folgt: Wir durchlufen ds Arry einml von Anfng is Ende Dei merken wir uns zwei Dinge: einen ktuellen Kndidten für ds Mehrheitselement, sowie einen Zähler Anfngs setzen wir den Zähler uf 0 und den Kndidten uf etws elieiges (er spielt keine Rolle solnge der Zähler 0 ist) Wir sehen uns nun die Elemente im Arry ncheinnder n Es git drei Fälle: () Ds ktuelle Element ist ungleich dem Kndidten und der Zähler ist 0: Dnn setzen wir den Kndidten uf unser ktuelles Element und den Zähler uf 1 () Ds ktuelle Element ist ungleich dem Kndidten und der Zähler ist > 0: Dnn reduzieren wir den Zähler um 1 (c) Ds ktuelle Element ist gleich dem Kndidten: Dnn erhöhen wir den Zähler um 1 Wir werde folgendes zeigen: Flls es ein Mehrheitselement git, dnn muss der Kndidt nch dem Durchlufen des gnzen Arrys dieses Element sein Wir müssen lso nur noch diesen Kndidten prüfen, indem wir zählen wie oft er im Arry vorkommt (m Zählerstnd m Schluss lässt sich dies nicht lesen) Es ist nicht trivil zu sehen, weshl dieser Algorithmus korrekt ist Korrektheitseweis: Wir eweisen folgende Aussge per Induktion üer die Länge des Arrys: Flls m ds Mehrheitselement im Arry ist, ist unser Kndidt m Ende m und unser Zähler ist > 0 Achtung: Andersherum gilt ds nicht! Induktionsnfng: Die Aussge stimmt triviler weise für Arrys der Länge 1 Induktionsnnhme: Wir nehmen n, die Aussge stimmt für lle Arrys die weniger ls n Elemente hen Induktionsschritt: Unter Verwendung der Annhme zeigen wir, dss die Aussge uch für Arrys der Länge n stimmt Wir unterscheiden zwei Fälle Entweder der Zähler wird nch dem ersten Schritt nie wieder 0 Dnn muss ds erste Element öfter vorkommen ls lle nderen zusmmen D dieses Element in unserem Algorithmus von Anfng n der Kndidt wr, ist die Aussge in diesem Fll korrekt Andernflls nehmen wir n der Zähler wird nch genu k Schritten 0 Nch Induktionsnnhme wissen wir lso, dss kein Element die Mehrheit unter den ersten k Elementen ht Flls es ein Mehrheitselement m git, so muss es folglich die Mehrheit unter den restlichen n k Elementen hen D unser Zähler nch k Schritten wieder im Anfngszustnd ist, können wir die restlichen Elemente getrennt etrchten Nch Induktionsnnhme ist der Zähler nch dem Durchlufen der letzten n k Elemente > 0 und m ist dnn unser Kndidt Beispielcode: // r e t u r n s t h e m j o r i t y element or 1 i f none e x i s t s (we ssume A[ i ] >0) int m j o r i t y ( const vector <int>& A, int l, int r ) int cndidte, count = 0 ; i f ( c n d i d t e!= A[ i ] && count == 0) c ndidte = A[ i ] ; count = 1 ; else i f ( c n d i d t e!= A[ i ] && count!= 0) count ; else // c n d i d t e == A[ i ] ++count ; count = 0 ; i f (A[ i ] == c n d i d t e ) ++count ; i f ( count > r l + 1) 4

5 return cndi dte ; else return 1; 5