Abgabe: (vor der Vorlesung) Aufgabe 2.1 (P) O-Notation Beweisen Sie die folgenden Aussagen für positive Funktionen f und g:

Transkript

1 TECHNISCHE UNIVERSITÄT MÜNCHEN FAKULTÄT FÜR INFORMATIK Lehrstuhl für Sprachen und Beschreibungsstrukturen SS 2009 Grundlagen: Algorithmen und Datenstrukturen Übungsblatt 2 Prof. Dr. Helmut Seidl, S. Pott, V. Prinz Abgabe: (vor der Vorlesung) Aufgabe 2.1 (P) O-Notation Beweisen Sie die folgenden Aussagen für positive Funktionen f und g: a) f(n) + g(n) Ω(f(n)) b) o(f(n)) O(f(n)) c) g(n) O(f(n)) f(n) + g(n) O(f(n)) Beweisen oder widerlegen Sie: d) 4 n O(2 n ) e) 27 2 n + n log 2 n Ω(n) f) n 2 n Θ(1) Lösungsvorschlag 2.1 a) Für c = 1, n 0 = 1 gilt: n n 0 : f(n) cf(n). Da g(n) 0 gilt weiterhin n n 0 : f(n) + g(n) cf(n). Damit existiert ein c > 0 und ein n 0 N mit n n 0 : f(n)+g(n) cf(n). Dies ist aber die Definition von f(n)+g(n) = Ω(f(n)). b) o(f(n)) O(f(n)): Es muss gezeigt werden, dass jede beliebige Funktion h(n) o(f(n)) auch in O(f(n)) liegt: h(n) o(f(n)) c > 0 n 0 N n n 0 : h(n) c f(n) c > 0 n 0 N n n 0 : h(n) c f(n) h(n) O(f(n)) c) g(n) O(f(n)) f(n) + g(n) O(f(n)) : g(n) O(f(n)) c > 0 n 0 N n n 0 : g(n) c f(n) c > 0 n 0 N n n 0 : g(n) + f(n) (c + 1) f(n) c > 0 n 0 N n n 0 : g(n) + f(n) c f(n) (c = c + 1) g(n) + f(n) O(f(n))

2 2 d) 4 n / O(2 n ): Es muss gezeigt werden d.h. ( c > 0 n 0 N n n 0 : 4 n c 2 n ) c > 0 n 0 N n n 0 : 4 n > c 2 n ) Seien c > 0 und n 0 N beliebig (aber fest). Dann folgt für alle n > log 2 c: n > log 2 c 2 n > c 2 n 2 n > c 2 n 4 n > c 2 n c > 0 n 0 N n = max{ log 2 c + 1, n 0 : 4 n > c 2 n ) e) 27 2 n + n log 2 n Ω(n): Mit c = 1 und n 0 = 1 gilt n n 0 : D.h.: 27 2 n + n log 2 n 27 2 n n = c n c > 0 n 0 N n n 0 : 27 2 n + n log 2 n c n f) Wissen von Blatt 1 Aufgabe 1.4 b) 2 2+n O(1) 2 n 2 2+n Ω(1): 2 Mit c n = 1 und n 0 = 2 gilt n n 0 : Somit folgt: 2 2+n 2 n Θ(1) n 2 n = c Aufgabe 2.2 (P) Komplexitätsanalyse Gegeben: Zahlenfolge A[0],..., A[n 1] und eine Zahl x in dieser Folge Algorithmus count(x,a): c = 0 ; for ( i =0; i<n ; i++) i f (A[ i ] == x ) c++; a) Bestimmen Sie die Komplexität dieses Algorithmus im worst case, best case und average case. b) Überlegen Sie sich einen count Algorithmus der auf sortierten Folgen arbeitet und bestimmen Sie die Komplexität im worst case, best case und average case. Vergleichen Sie dies mit den Ergebnissen aus Aufgabenteil a). c) Läßt sich die Komplexität verbessern indem man zunächst sortiert und anschließend den Algorithmus für sortierte Folgen anwendet?

3 3 Lösungsvorschlag 2.2 In dieser Aufgabe ging es darum die Laufzeit verschiedener Algorithmen anzugeben und zwar im besten, schlechtesten und durchschnittlichen Fall. Für die ersten zwei Fälle muss man sich in Abhängigkeit von n (also der Eingabegröße) einen bestimmten Fall überlegen, für den der Algorithmus besonders kurz bzw. besonders lange läuft. Wie dann die Laufzeit abgeschätzt wird, wurde in der Vorlesung an anderen Beispielen gezeigt. Für den average case muss man die durchschnittliche Laufzeit berechnen. D.h., man müsste die Laufzeit für jede mögliche Eingabe, hier A und x, berechnen und deren Summe durch die Anzahl der Möglichkeiten teilen. Dazu betrachten wir alle möglichen Instanzen, mit unterschiedlichem Verhalten des Algorithmus. In Teil b) also z.b. wie oft x in A vorkommt und an welcher Stelle x zum ersten Mal auftritt. Dann wird die Summe über diese Instanzen gebildet und mit ihrer Wahrscheinlichkeit multipliziert. Ist T (I) also die Laufzeit für I, erhalten wir I T (I) p(i) als durchschnittliche Laufzeit (da I p(i) = 1 muss nicht mehr geteilt werden). In den nachfolgenden Algorithmen wurde diese Summe soweit wie möglich reingezogen. Für T (I) O(1) ergibt sich z.b. O( I 1 p(i)) = O(1). Bei diesen Algorithmen muss die Wahrscheinlichkeit der verschiedenen Instanzen nur in den Schleifen genauer betrachtet werden. a) c = 0 ; for ( i =0; i<n ; i++) // O( n i f (A[ i ] == x ) c++; i=0 I T(I)*p(I)) Gesamtlaufzeit: O(1+n 1+1+1) = O(n) für alle Fälle da die Schleife stets vollständig durchlaufen wird und T(I) O(1) für alle Instanzen I. b) c = 0 ; for ( i =0; i<n ; i++) { // O( I i f (A[ i ] == x ) { c++; else { i f ( c > 0) k(i) i=0 T(I)*p(I)) Worst case: Alle Elemente kleiner gleich x = Schleife läuft bis zum Ende = O(n) Best case: Nur erstes Element gleich x = 2 Schleifen Durchläufe = O(1) Average case: Erstes x an Stelle j = j + #x Durchläufe. Da #x fast sicher gleich 1 ist, muss man nur die Position des ersten x unterscheiden. Die Wahrscheinlichkeit für das erste x an Stelle j ist gleich 1/n und somit erhält man für die Schleife: O( n 1 j+1 n (n+1) j=0 ) = O( ) = O( n+1) = O(n) n 2n 2 Dieser Ansatz bring also keine signifikante Verbesserung. c = 0 ; l = 0 ; r = n 1; while ( l <= r ) { // O( I m = ( l+r ) / 2 ; i f (A[m] == x ) { while (A[m] == x ) { // O( I m ; c++; m = ( l+r ) / 2 +1; while (A[m] == x ) { // O( I m++; c++; k(i) i=0 T(I)*p(I)) l(i) j=0 T(I)*p(I)) l (I) j=0 T(I)*p(I))

4 4 i f (A[m] > x ) l = m+1; else r = m 1; Für die inneren Schleifen ergibt sich, wie oben im worst case, l(i) + l (I) = n 1 und im average case l(i) + l (I) = 0. Der innere if-block hat somit einen Aufwand von O(n) (worst case) bzw. O(1) (average case), falls x gefunden ist, und O(1) sonst, da er dann nicht ausgeführt wird. Da der Rest der Schleife unabhängig von der Instanz stets in O(1) ist bestimmt der Aufwand des If-Blocks den Aufwand der gesamten (äußeren) Schleife. Worst case: Alle Elemente gleich x. Man findet x mit einem Schritt, benötigt dann aber 2 n/2 Schritte zum eigentlichen Zählen. Insgesamt: O(1 + 1 n) = O(n) Average case: Analog zur binären Suche in der Vorlesung ist k = log(n) und da der If-Block in O(1) ist erhält man insgesamt: O(log(n) 1 + 1) = O(log(n)) Best case: Man findet x im ersten Schritt (k = 1) und es kommt nur einmal vor. = O(1 + 1) = O(1) Hier erhält man eine verbesserte Schranke für den average case. c) Nein, denn Sortieren hat eine Komplexität von O(n log(n)) die bereits über der Komplexität des Algorithmus für unsortierte Folgen liegt. Auch ein Test auf Sortiertheit benötigt O(n) Schritte. Soll aber ohnehin sortiert werden entstehen keine zusätzlichen Kosten und man kann durch Verwendung des Algorithmus für sortierte Arrays ggf. Laufzeit sparen. Aufgabe 2.3 [5 Punkte] (H) O-Notation Beweisen Sie die folgenden Aussagen für positive Funktionen f und g: a) O(f(n) + g(n)) O(f(n)) + O(g(n)) b) O(f(n)) + O(g(n)) O(f(n) + g(n)) Dabei ist O(f(n)) + O(g(n)) = {h f (n) + h g (n) h f (n) O(f(n)) h g (n) O(g(n)) Beweisen oder widerlegen Sie: c) 4n n O(n 3 ) d) n Ω(n log 2 n) e) 9n + 27n 2 Θ(n) Lösungsvorschlag 2.3 a) O(f(n) + g(n)) O(f(n)) + O(g(n)): Es muss gezeigt werden, dass jede beliebige Funktion h(n) O(f(n) + g(n)) auch

5 5 in O(f(n)) + O(g(n)) liegt, d.h., dass h(n) als Summe von zwei Funktionen h f (n) O(f(n)) und h g (n) O(g(n)) dargestellt werden kann: Außerdem gilt: h(n) O(f(n) + g(n)) c > 0 n 0 N n n 0 : h(n) c f(n) + g(n) c > 0 n 0 N n n 0 : h(n) c g(n) c f(n) c > 0 (h(n) c g(n)) O(f(n)) h(n) = (h(n) c g(n)) + c g(n) und c g(n) O(g(n)). Für die Funktionen h f (n) = h(n) c g(n) und h g (n) = c g(n) gilt: h(n) = h f (n) + h g (n) h f (n) O(f(n)) h g (n) O(g(n)) D.h. h(n) O(f(n)) + O(g(n)) b) O(f(n)) + O(g(n)) O(f(n) + g(n)): Es muss gezeigt werden, dass jede beliebige Funktion h(n) O(f(n)) + O(g(n)) auch in O(f(n) + g(n)) liegt. Dies wird gezeigt, indem aus der Darstellung h f (n) + h g (n) für h(n) (und den Eigenschaften h f (n) O(f(n)) und h g (n) O(g(n))) geeignete c > 0 und n 0 N hergeleitet werden: h(n) O(f(n)) + O(g(n)) h f (n) O(f(n)) h g (n) O(g(n)) : h(n) = h f (n) + h g (n) c f > 0 n f N n n f : h f (n) c f f(n) c g > 0 n g N n n g : h g (n) c g g(n) c f, c g > 0 n f, n g N n max{n f, n g : h f (n) + h g (n) c f f(n) + c g g(n) c = max{c g, c f > 0 n 0 = max{n f, n g N n n 0 : h f (n) + h g (n) c (f(n) + g(n)) h(n) = h f (n) + h g (n) O(f(n) + g(n)) c) 4n n O(n 3 ): Mit c = und n 0 = 1 gilt n n 0 : 4n n 4n n 3 = ( )n 3 = c n 3 D.h.: c > 0 n 0 N n n 0 : 4n n c n 3 d) n / Ω(n log 2 n): Es muss gezeigt werden ( c > 0 n 0 N n n 0 : n c n log 2 n) d.h. c > 0 n 0 N n n 0 : n < c n log 2 n)

6 6 Seien c > 0 und n 0 N beliebig (aber fest). Dann folgt für alle n > 2 1/c : e) 9n + 27n 2 Θ(n): n > 2 1/c log 2 n > 1/c c log 2 n > 1 c n log 2 n > n c > 0 n 0 N n = max{ 2 1/c + 1, n 0 : n < c n log 2 n) 9n + 27n 2 = (9 + 27) n D.h. mit c = und n 0 = 1 gilt für alle n > n 0 sowohl 9n + 27n 2 c n als auch 9n + 27n 2 c n Und damit gilt sowohl 9n + 27n 2 O(n) als auch 9n + 27n 2 Ω(n) Daraus folgt 9n + 27n 2 O(n) Ω(n) = Θ(n) Aufgabe 2.4 [5 Punkte] (H) Komplexitätsanalyse Gegeben: Zahlenfolge A[0],..., A[n 1] Algortihmus insert(a): for ( i =1; i<n ; i++) { x = A[ i ] ; j = i 1 ; while ( j >= 0 && A[ j ] > x ) { A[ j + 1 ] = A[ j ] ; j ; A[ j + 1 ] = x ; a) Geben Sie für obigen Algorithmus Komplexitätsabschätzungen für den best und worst case an. b) Finden Sie für beide Fälle eine Instanz I so dass T(I) in Θ der in Teil a) gefundenen Schranke liegt.

7 7 Lösungsvorschlag 2.4 a) for ( i =1; i<n ; i++) { // n 1 i=1 T(I) x = A[ i ] ; j = i 1 ; while ( j >= 0 && A[ j ] > x ) { // k j=0 T(I ) A[ j + 1 ] = A[ j ] ; j ; A[ j + 1 ] = x ; best case: k = 1 (Schleife wird nie durchlaufen) = O(1) damit äußere Schleife O(n ( (1 + 1) + 1)) = O(3n) = O(n) worst case: Für die innere Schleife gilt immer k = i 1 = O(i 2) für i {1,..., n 1 Für die äußere Schleife ergibt sich also: O( n 1 n(n 1) i=1 ( i + 1)) = O(3 (n 1) + 2 ) O(n 2 ). 2 b) best case: [1, 2, 3,..., n] damit ist für alle i A[i] > A[i 1] und die while-schleife wird nicht betreten. Schlampig: n 1 i=1 ( ) = (n 1) 3 = 3n 6 Schritte worst case: [n, n 1, n 2,..., 1] damit ist für alle i A[i] < A[i 1] und die while-schleife wird durchlaufen bis j = 0 ist. Schlampig: n 1 n (n 1) i=1 (2+2i+1) = (n 1) = 2 n 2 9 Schritte