Informatik II. Algorithmen und Datenstrukturen. Vorläufige Version 1 c 2002 Peter Thiemann

Transkript

1 Informatik II Algorithmen und Datenstrukturen Vorläufige Version 1 c 2002 Peter Thiemann

2 1 Einführung 1.1 Inhalt Wichtige Datentypen und ihre Implementierung (Datenstrukturen) Operationen auf Datenstrukturen (Algorithmen) Komplexitätsanalyse Laufzeitanalyse der Operationen Speicherverbrauchsanalyse Techniken des Algorithmenentwurfs Informell: Korrektheit der Algorithmen Vorläufige Version 2 c 2002 Peter Thiemann

3 1.2 Ziele Reproduktion Anwendung Implementierung Auswahlkriterien Komplexitätsanalyse einfacher Algorithmen Entwurfsideen für Algorithmen Vorläufige Version 3 c 2002 Peter Thiemann

4 1.3 Hilfsmittel elementare Mathematik (Folgen, Reihen, Grenzwerte, Abschätzungen, Kombinatorik) algorithmische Notation z.b. Programmiersprache Vorläufige Version 4 c 2002 Peter Thiemann

5 1.4 Literatur T. Ottmann und P. Widmayer, Algorithmen und Datenstrukturen, 4. Auflage, Spektrum Verlag, Vorläufige Version 5 c 2002 Peter Thiemann

6 2 Grundlagen der Komplexitätsanalyse Referenzmaschine für Komplexitätsanalyse: Turingmaschine Definition 1 Sei M Turingmaschine für einen Algorithmus A(x) 1. Laufzeit von A bei Eingabe von x T (x) = Schritte, die M zur Berechnung von A(x)benötigt 2. Speicherplatzbedarf von A bei Eingabe von x S(x) = Bandplätze, die M zur Berechnung von A(x)benötigt Weitere Möglichkeiten für Referenzmaschinen 1. RAM (random access machine) 2. RM (register machine) Vorläufige Version 6 c 2002 Peter Thiemann

7 Beispiel: tm-find0 Turingmaschine über Alphabet {0, 1}, die feststellt, ob die Eingabe 0 enthält B q0 q0 N,0,qf R,B,q0 N,B,qf Startzustand q 0 ; Endzustand q f ; akzeptiert, falls Kopf auf nicht-leerem Platz x T(x) S(x) Vorläufige Version 7 c 2002 Peter Thiemann

8 Probleme mit der Definition 1. Komplexität hängt von konkreter Eingabe ab 2. Exakte Schrittzahl selten von Interesse 3. Algorithmen werden nicht in Form von Turingmaschinen aufgeschrieben Vorläufige Version 8 c 2002 Peter Thiemann

9 2.1 Abstraktion von der Eingabe Anstatt konkreter Eingabe x betrachte alle Eingaben der Größe n = x Bestimme Anzahl der Schritte/Plätze in Abhängigkeit von n neues Problem: Eingaben gleicher Größe können unterschiedlich viele Schritte/Plätze verbrauchen im Beispiel tm-find0 Eingabe braucht einen Schritt Eingabe braucht vier Schritte Eingabe braucht neun Schritte Vorläufige Version 9 c 2002 Peter Thiemann

10 Arten von Komplexität Lösung: extrahiere einen Wert aus allen Werten T (x) mit x = n T min (n) = min{t (x) x = n} best-case Komplexität Tmax(n) = max{t (x) x = n} worst-case Komplexität T (n) = x =n T (x) q n(x) q n (x) ist Wahrscheinlichkeit, dass x als Eingabe der Größe n auftritt average-case Komplexität Vorläufige Version 10 c 2002 Peter Thiemann

11 Bewertung best-case Komplexität leicht zu bestimmen, meist unwichtig worst-case Komplexität oft zu pessimistisch average-case Komplexität praktisch relevant schwierig zu bestimmen Wahrscheinlichkeitsverteilung meist unbekannt in Beweisen wird oft Gleichverteilung angenommen d.h. q n (x) = m 1 wobei m = {x x = n} Vorläufige Version 11 c 2002 Peter Thiemann

12 Beispiel: Laufzeitanalyse von tm-find0 best-case T min (n) = 1 falls x = 0... or x = ε worst-case Tmax(n) = n + 1 falls x = average-case Annahme: Gleichverteilung, d.h. q n (x) = 2 n T (n) = (0.5) n (0.5) n + (n + 1) (0.5) n = ( n k=1 k (1) 2 k ) + (n + 1) 2 n Vorläufige Version 12 c 2002 Peter Thiemann

13 Nebenrechnung n k=1 k 2 k = n 2 n = n n n. + 2 n (2) Jede Zeile von (2) ist (Endstück einer) geometrischen Folge n k=0 q k = qn+1 1 q 1 (3) Einsetzen von q = 1/2 in (3) ergibt n (1/2) k = (1/2)n+1 1 1/2 1 k=0 = 2(1/2) n = 2 2 n (4) Vorläufige Version 13 c 2002 Peter Thiemann

14 In Zeile j {1,..., n} von (2) steht gerade (5) 2 j + 2 (j+1) n = n k=0 (1/2)k j 1 k=0 (1/2)k (4) = 2 2 n (2 2 (j 1) ) = 2 n + 2 (j 1) Also ergibt die Summe aller Zeilen in (2): n j=1 2 n + 2 (j 1) = n 2 n + n j=1 2 (j 1) Einsetzen von (6) in (1) ergibt insgesamt = n 2 n + n 1 j=0 2 j (6) (4) = n 2 n (n 1) T (n) = n 2 n (n 1) + (n + 1) 2 n = n 2 (n 1) = n 2 2 n = 2 2 n (7) Vorläufige Version 14 c 2002 Peter Thiemann

15 2.2 Komplexität eines Problems Unterschied: Komplexität eines Problems Komplexität eines Algorithmus Komplexität eines Problems ist die minimale Laufzeit (Speicherplatzbedarf) eines Algorithmus, der das Problem löst Theorie: für manche Probleme gibt es untere Schranken, d.h. kein Algorithmus kann schneller laufen, als die untere Schranke angibt oft schwer zu bestimmen Komplexität eines konkreten Algorithmus liefert obere Schranke für ein Problem Falls die Komplexität eines Algorithmus der unteren Schranke eines Problems entspricht, so liegt eine genaue Schranke vor. Vorläufige Version 15 c 2002 Peter Thiemann

16 2.3 Wachstumsklassen von Funktionen Genaue Zahl von Schritten selten interessant und/oder technisch aufwändig zu ermitteln Variiert zwischen Implementierungen Verhalten wichtiger für große Eingaben asymptotisches Verhalten Unabhängigkeit von konstanten Faktoren Änderung bei Technologiewechsel Wachstumsverhalten von Funktionen ist interessanter Vorläufige Version 16 c 2002 Peter Thiemann

17 Definition: Landausche O-Notation Seien f, g : N R + Funktionen f O(g) f wächst nicht schneller als g, falls ( c R + ) ( n 0 N) ( n N) n > n 0 f(n) c g(n) f Ω(g) f wächst mindestens so schnell wie g, falls g O(f) f Θ(g) f genauso schnell wie g, falls f O(g) und g O(f) f o(g) f wächst langsamer als g, falls lim n f(n) g(n) = 0 f ω(g) f wächst schneller als g, falls g o(f) Vorläufige Version 17 c 2002 Peter Thiemann

18 Schreibweise Schreibe O(n log n) anstelle von O(λn.n log n) oder O(g) mit g(n) = n log n Oft: f = O(g) anstatt f O(g) Vorsicht, da Gesetze von = nicht gelten! Vorläufige Version 18 c 2002 Peter Thiemann

19 Beispiele Sei f 1 (n) = n; f 2 (n) = n; f 3 (n) = n k für k 1; f 4 (n) = 2 n f 1 O(f 2 ), denn für alle n > n 0 = 1 gilt: n n (mit c = 1) f 2 O(f 3 ), denn für alle n > n 0 = 1 gilt: n n k (mit c = 1; für alle k 1) f 3 O(f 4 ), denn es gilt sogar f 3 o(f 4 ): lim n n k 2 n = lim n nach l Hospital (k-fach angewendet) Zur Erinnerung: Regel von l Hospital lim n k n k 1 ln 2 2 n =... = lim n f (n) g (n) = c lim n falls lim n f(n) = lim n g(n) {0, ± } k! (ln 2) k 2 n = 0 f(n) g(n) = c Vorläufige Version 19 c 2002 Peter Thiemann

20 Visualisierung des Größenwachstums log(x) sqrt(x) x x*x x*x*x x*x*x*x exp(x) Vorläufige Version 20 c 2002 Peter Thiemann

21 Wachstumshierarchie O(1): konstante Funktionen O(log n): Logarithmische Funktionen O(log 2 n): Quadratisch logarithmische Funktionen O(n): Lineare Funktionen O(n log n): keine spezielle Bezeichnung O(n 2 ): quadratische Funktionen O(n 3 ): kubische Funktionen O(n k ): polynomielle Funktionen (für festes k 1) genauer: f heißt polynomiell beschränkt, wenn es ein Polynom p mit f = O(p) gibt O(2 n ): exponentielle Funktionen genauer: f wächst exponentiell, wenn es ein ɛ > 0 mit f = Θ(2 nɛ ) gibt Vorläufige Version 21 c 2002 Peter Thiemann

22 Skalierbarkeit Maximale Eingabelänge bei gegebener Rechenzeit Annahme: Rechenschritt Sekunden. Laufzeit T(n) 1 Sekunde 1 Minute 1 Stunde n n log n n n n Vorläufige Version 22 c 2002 Peter Thiemann

23 Maximale Eingabelänge in Abhängigkeit von Technologie Algorithmus mit Laufzeit T (n) p max. Eingabelänge mit alter Technologie pneu max. Eingabelänge mit neuer Technologie neue Technologie: 10-mal so schnell 10 T (p) = T (pneu) T (n) pneu Begründung n 10p n log n (fast 10)p log 10p = log p + log 10 log p n p n p n p Vorläufige Version 23 c 2002 Peter Thiemann

24 Beispiel: Exponentieller Algorithmus SAT (Erfüllbarkeit einer Formel der Aussagenlogik) Frage: Gegeben eine logische Formel mit n Variablen. Gibt es eine Belegung der Variablen, so dass die Formel wahr (erfüllt) ist? Alternativ: Gegeben ein kombinatorischer Schaltkreis mit n Eingängen. Gibt es eine Belegung der Eingänge, so dass der Ausgang 1 ist? Naive Lösung: Durchprobieren aller 2 n möglichen Belegungen. exponentielle Laufzeit Anmerkung: Es ist nicht bekannt, ob dieser Algorithmus der bestmögliche ist. Vorläufige Version 24 c 2002 Peter Thiemann

25 Weitere Eigenschaften Falls p 1 und p 2 Polynome vom Grad d 1 bzw. d 2 mit positivem Leitkoeffizienten sind, so gilt p 1 Θ(p 2 ) d 1 = d 2 p 1 o(p 2 ) d 1 < d 2 p 1 ω(p 2 ) d 1 > d 2 Für alle k > 0 und ε > 0 gilt log k n o(n ε ) dabei ist log k n = (log n) k 2 n/2 o(2 n ) Vorläufige Version 25 c 2002 Peter Thiemann

26 Rechenregeln für O f O(f) O(f) = O(O(f)) O(k f) = O(f) für Konstante k 0 O(k + f) = O(f) für Konstante k 0 O(f) O(g) = O(f g) O(f) + O(g) = O(max(f, g)) Multiplikationsregel Additionsregel Vorläufige Version 26 c 2002 Peter Thiemann

27 Beweis für Additions- und Multiplikationsregel Sei F O(f) und G O(g), d.h. es gibt c F, c G R + sowie n F, n G N, sodass ( n > n F ) F (n) c F f(n) und ( n > n G ) G(n) c G g(n) ist. Sei nun n 0 = max(n F, n G ). Offenbar gilt für c 1 = c F c G, dass ( n > n 0 ) F (n) G(n) c F f(n) c G g(n) = c(f g)(n). Es gilt also die Multiplikationsregel: F G O(f g). Weiter gilt für c 2 = c F + c G, dass ( n > n 0 ) F (n) + G(n) c F f(n) + c G g(n) c 2 (max(f, g))(n). Es gilt also die Additionsregel: F + G O(max(f, g)). Vorläufige Version 27 c 2002 Peter Thiemann

28 Die Wachstumsordnung auf Funktionen Definition 2 Eine Relation R M M, wobei M Menge, heißt reflexiv, falls ( m M) m R m; transitiv, falls ( m 1, m 2, m 3 M) m 1 R m 2 m 2 R m 3 m 1 R m 3 ; symmetrisch, falls ( m 1, m 2 M) m 1 R m 2 m 2 R m 1 ; Vorordnung, falls R reflexiv und transitiv; Äquivalenzrelation, falls R reflexiv, transitiv und symmetrisch. Vorläufige Version 28 c 2002 Peter Thiemann

29 Für M = {f r : N R + } definiere Es gilt: ist transitive Relation ist Vorordnung f g f g f g f O(g) f g f o(g) Die Relation, definiert durch f g, falls f g g f, ist eine Äquivalenzrelation f g f Θ(g) Bemerkung: Die Relationen,, auf Funktionen haben ähnliche Eigenschaften wie <,, = auf Zahlen. Unterschied: Aus f g folgt nicht f = g! Vorläufige Version 29 c 2002 Peter Thiemann

30 2.4 Kostenmaße Programmiersprache statt Turingmaschine Einheitskostenmaß Konkrete Maschine hat feste Wortbreite (z.b. 32 Bit); jedes Datenelement belegt gleichen Speicherplatz unabhängig von der Größe Turingmaschinen für Grundrechenarten, Vergleiche, Kopieren von 32 Bit Zahlen benötigen 32 c + d Schritte eine Konstante unabhängig von der Größe der Zahl Aufwand für diese Operationen ist O(1) logarithmisches Kostenmaß Jedes Datenelement belegt Platz in Abhängigkeit von seiner Größe Platzbedarf für Langzahl n in Dualdarstellung: log 2 n + 1 Grundrechenarten, Vergleiche, Kopieren benötigen O( log 2 n + 1 ) Schritte Vorläufige Version 30 c 2002 Peter Thiemann

31 2.5 Kosten für Programmteile Zuweisung: T (x := E) = E + 1 O(1) (E Ausdruck, ohne Funktionsaufrufe; Einheitskostenmaß) Sequenz: T (S 1 ;... ; S n ) = T (S 1 ) T (S n ) Konditional: T (if E S 1 S 2 ) = T (E) + max(t (S 1 ), T (S 2 )) Schleife: Rekursion: T (while E do S) = n i=1 T i(e) + T i (S) T selbst rekursiv definiert Bemerkung: oft werden nur wichtige Operationen gezählt: Vergleiche, Datenbewegungen, usw Vorläufige Version 31 c 2002 Peter Thiemann

32 2.6 Beispiele Algorithmus Bubble-Sort Sortiert die Zahlen im Array a[1..n] durch wiederholtes Vertauschen. repeat for (i = 1; i < n; i++) if (a[i] > a[i+1]) swap(a, i, i+1) until (keine Vertauschungen mehr notwendig) Abschätzen der Anzahl von Vergleichen: Worst Case: Innere Schleife: n 1 Vergleiche, maximal n Durchläufe (Minimum an a[n]) der äußeren Schleife O(n 2 ) Best Case: Array ist bereits sortiert: Ende nach einem Durchlauf O(n) Average Case: auch O(n 2 ) viele Vergleiche ausgeführt. Vorläufige Version 32 c 2002 Peter Thiemann

33 2.6.2 Das Maxsummenproblem Problem MaxSum: Betrachte ein Array a[1..n] von ganzen Zahlen. Berechne max{f(i, j) 1 i j n}, wobei f(i, j) = a i a j. Rechenschritte sind arithmetische Operationen und Vergleiche. Naiver Algorithmus Berechne alle Werte von f(i, j) und bestimme dabei das Maximum. m := f (1,1) for (i = 1; i <= n; i++) for (j = i; j <= n; j++) if (f (i,j) > m) m := f (i,j) Die Berechung von f(i, j) benötigt j i Additionen. Vorläufige Version 33 c 2002 Peter Thiemann

34 Analyse Naiver Algorithmus Es gibt j Paare der Form (, j) # Vergleiche: V 1 (n) = n j=1 j O(n2 ) # Additionen: A 1 (n) = = n i=1 n n (j i) j=i n i i=1 k=1 O(n 3 ) # Rechenschritte: T 1 (n) = V 1 (n) + A 1 (n) O(n 2 ) + O(n 3 ) = O(n 3 ). Tatsächlich auch Ω(n 3 ). k Vorläufige Version 34 c 2002 Peter Thiemann

35 2.6.3 Der etwas bessere Algorithmus Verwende f(i, j + 1) = f(i, j) + a j+1 m := f (1,1) for (i = 1; i <= n; i++) fij := 0 for (j = i; j <= n; j++) fij := fij + a[j] if (fij > m) m := fij Damit braucht man für alle f(i, )-Werte genau (n i + 1) Additionen. # Vergleiche: V 2 (n) = V 1 (n) O(n 2 ). # Additionen: A 2 (n) = n i=1 (n i + 1) = n + n 1 k=1 k O(n2 ). # Rechenschritte: T 2 (n) = V 2 (n) + A 2 (n) O(n 2 ). Vorläufige Version 35 c 2002 Peter Thiemann

36 2.6.4 Divide-And-Conquer Algorithmus a Zur Lösung von MaxSum auf a[1..n] unterteile die Menge der Index-Paare (i, j) in drei Klassen: 1. 1 i, j n/2 MaxSum auf a[1..n/2] 2. 1 i n/2 < j n neues Problem auf a[1..n]! 3. n/2 < i j n MaxSum auf a[n/2+1..n] Die Probleme 1 und 3 sind halb so groß wie das ursprüngliche Problem und werden rekursiv gelöst. Für Problem 2 setze g(i) = a i a n/2 für 1 i n/2 h(j) = a n/ a j für n/2 < j n f(i, j) = g(i) + h(j) Es gilt: f(i, j) maximal g(i) und h(j) maximal a (lat. divide et impera) teile und herrsche Vorläufige Version 36 c 2002 Peter Thiemann

37 Berechne nacheinander (in n/2 1 Additionen) g(n/2) = a n/2 g(n/2 1) = a n/2 1 + a n/2. g(1) = a a n/2 und daraus den maximalen Wert von g in (n/2 1) Vergleichen. Berechne den maximalen Wert von h analog. Damit ergeben sich für das zweite Problem insgesamt n 1 Additionen und n 2 Vergleiche, also 2n 3 Operationen, obwohl die Klasse n 2 /4 Paare (i, j) enthält. Gesamtergebnis aus Lösungen für 1, 2 und 3 durch 2 Vergleiche. Vorläufige Version 37 c 2002 Peter Thiemann

38 Rekursionsgleichung T 3 (1) = 0 T 3 (n) = 2T 3 (n/2) + 2 n Lösungsansatz: Angenommen n = 2 k T 3 (2 k ) = 2T 3 (2 k 1 ) + 2 k+1 1 = 4T 3 (2 k 2 ) + 2 k k+1 1 = 8T 3 (2 k 3 ) + 2 k k k+1 1 =... = 2 k T 3 (2 k k ) + k 2 k+1 k i=1 2i 1 = 0 + 2k 2 k 2 k + 1 = (2k 1)2 k + 1 Aus n = 2 k ergibt sich k = log 2 n und somit = (log 2 n 1)n + 1 O(n log n) Vorläufige Version 38 c 2002 Peter Thiemann

39 2.6.5 Scanline Algorithmus MaxSum lässt sich mit einem Durchlauf durch a[1..n] lösen Gesucht: maxsum k = max{ j l=i a l 1 i j k} Hilfsgröße: maxtail k = max{ k l=i a l 1 i k} Für k = 1 setze maxsum 1 = a 1 und maxtail 1 = a 1. Für k = 1,..., n 1 setze maxtail k+1 = max{ k+1 l=i a l 1 i k + 1} = max({a k+1 + k l=i a l 1 i k} {a k+1 }) = max(a k+1 + maxtail k, a k+1 ) maxsum k+1 = max{ j l=i a l 1 i j k + 1} = max({ j l=i a l 1 i j k} { k+1 l=i a l 1 i k + 1}) = max(maxsum k, maxtail k+1 ) T 4 (n) = (n 1) 3 = 3n 3 Operationen Vorläufige Version 39 c 2002 Peter Thiemann

40 2.6.6 Zusammenstellung der Ergebnisse Naiv: T 1 (n) O(n 3 ) Besser: T 2 (n) O(n 2 ) Divide-and-Conquer: T 3 (n) O(n log n) Scanline: T 4 (n) O(n) Bemerkung: Es ist möglich, den Scanline Algorithmus aus dem naiven Algorithmus herzuleiten! Vorläufige Version 40 c 2002 Peter Thiemann

41 2.7 Mastertheorem Gegeben eine Rekursionsgleichung für T : N R. c falls n d T (n) = at (n/b) + f(n) falls n > d. Dabei sind c 1 und d 1 natürliche Zahlen, a 1 und b > 1 reelle Konstanten und f eine reelle Funktion mit f(n) 0 für n d. Unterscheide drei Fälle: 1. ( ɛ > 0) f(n) O(n log b a ɛ ) 2. ( k 0) f(n) Θ(n log b a (log n) k ) 3. ( ɛ > 0) f(n) Ω(n log b a+ɛ ) und ( δ < 1) (n d) af(n/b) δf(n) T (n) Θ(n log b a ) T (n) Θ(n log b a (log n) k+1 ) T (n) Θ(f(n)) Vorläufige Version 41 c 2002 Peter Thiemann

42 Beispiele Mastertheorem 1. T (n) = 4T (n/2) + n; a = 4, b = 2, f(n) = n. Mit n log 2 4 = n 2 ist T (n) Θ(n 2 ), da Fall 1 gilt: n = f(n) O(n 2 ɛ ) für ɛ = 1. Genau: T (n) = 2n 2 n 2. T (n) = T (n/2) + 1; a = 1, b = 2, f(n) = 1. Mit n log 2 1 = 1 ist T (n) Θ(log n), da Fall 2 mit k = 0 gilt. Genau: T (n) = log n T (n) = 2T (n/2) + n log n; a = 2, b = 2, f(n) = n log n. Mit n log 2 2 = n ist T (n) Θ(n log 2 n), da Fall 2 mit k = 1 gilt. Vorläufige Version 42 c 2002 Peter Thiemann

43 4. T (n) = T (n/3) + n log n; a = 1, b = 3, f(n) = n. Mit n log 3 1 = 1 ist T (n) Θ(n), da Fall 3 gilt: f(n) = Ω(n 0+ɛ ) für ɛ = 1 und für δ = 1/3 gilt af(n/b) = (n/3) log(n/3) = (n/3)(log n log 3) (n/3) log n = f(n)/3 Vorläufige Version 43 c 2002 Peter Thiemann