Algorithmen & Datenstrukturen

Transkript

1 Algorithmen & Datenstrukturen 1. Grundlagen 1.2 Analyse von Algorithmen 1

2 Einführung (1) Was ist ein Algorithmus? Der Begriff Algorithmus ist vom Namen des arabischen Mathematikers Muhammed al-chwarizmi, etwa abgeleitet. Es gibt viele unterschiedliche Definitionen von Algorithmen. Es ist ein Verfahren zur Lösung eines Problems, unabhängig von Implementierung in konkreter Programmiersprache oder ein Algorithmus ist eine Verarbeitungsvorschrift, die so präzise formuliert ist, dass sie von einem mechanisch oder elektrisch arbeitenden Gerät in endlich vielen Schritten durchgeführt werden kann. Alle Programme, die auf Computern ausgeführt werden können, stellen Beschreibungen von Algorithmen dar. Vorteil: Konzentrieren auf das Problem, nicht auf die Eigenarten der Sprache. 2

3 Erinnerung: EPR 1. Unter einem Algorithmus versteht man eine präzise Verfahrensvorschrift, 2. wie man in Schritten von den Eingangsdaten zu dem Ergebnisdaten gelangt. 3. Jeder Schritt des Verfahrens muss in endlicher Zeit ausführbar sein, 4. der Algorithmus endlich sein und 5. determinierter Algorithmus: jede Ausführung muss für diesselben Eingangsdaten auch die diesselben Ergebnisdaten liefern. Beispiele: ein Kochrezept, eine Montageanleitung für eine Sitzbank und ein Verfahren zum Sortieren von Zahlen. 3

4 Einführung (2) Gemeinsame Konzepte der Programmiersprachen, um Algorithmen auf Computern umzusetzen: Wertzuweisungen/Ausdrücke (in C: y = 2*x + c) Bedingte Anweisung Iterative Anweisung Ein- und Ausgabeanweisung (in C: if/else, switch/case) (in C: for, while, do/while) (in C: scanf, printf) Prozedur-/Funktionsaufrufe 4

5 Einführung (3) Welche Eigenschaften interessieren uns? Korrektheit (E. Dijkstra: Testen kann die Anwesenheit, aber nicht die Abwesenheit von Fehlern zeigen.) Laufzeit (wie schnell wird das Problem gelöst?) Speicherplatz (wie viel Speicherplatz wird benötigt?) Weitere interessante Eigenschaften: Kommunikationszeit (parallele/verteilte Algorithmen) Güte (exakte oder approximative Lösung?) 5

6 Einführung (4) Wichtiger als Performance?? Wartbarkeit/Erweiterbarkeit Entwicklungszeit/Einfachheit Zuverlässigkeit/Ausfallsicherheit Bedienbarkeit Objektorientierte Programmentwicklung (Dr. Rethmann/Dr. Davids) Software-Engineering (Dr. Beims) 6

7 Einführung (5) Wenn ein Problem mit verschiedenen Algorithmen gelöst werden kann: Wie bewerten/vergleichen wir Algorithmen? Wann ist ein Algorithmus besser als ein anderer? Was sind gute/schlechte Algorithmen? Laufzeit messen und vergleichen??? Probleme beim Messen und Vergleichen der Laufzeit: unterschiedlich schnelle Hardware/gute Compiler unterschiedliche Betriebssysteme/Laufzeitumgebungen unterschiedliche Eingabedarstellungen/Datenstrukturen 7

8 Einführung (6) Beispiel: Systemumgebung 1: Hardware: Pentium III mobile, 1GHz, 256 MB, Q Linux: Kernel , gcc Windows: XP Home (SP1), Borland C Systemumgebung 2: Hardware: Pentium M (Centrino), 1,5GHz, 512 MB, Q Linux: Kernel 2.6.4, gcc Windows: XP Home (SP2), Borland C Systemumgebung 3: Hardware: Intel Core) Intel i7-4800, 2.7 GHz, 16 GByte, Q Linux: Kernel , gcc WIndows: Windows 8, Visual Studio

9 Einführung (7) Messergebnisse: Zahlen sortieren input size System 1 System 2 System 3 Linux XP [s] Linux XP [s] Linux W8 [s] Problem: Bewertung der Messergebnisse Unterschiede aufgrund Compiler, Betriebssystem, Taktfrequenz, Prozessor? Skalierung: doppelte Eingabegröße, vielleicht vierfache Laufzeit? 9

10 Einführung (8) Laufzeit beschreibbar durch Polynom ax 2 +bx+c??? Sys Reg 1 Sys f(x) [ms] Reg x [10 3 ] Reg.1: 10.6 x x Reg.2: 1.1 x x

11 Einführung (9) Zur Information: Die Koeffizienten werden bestimmt durch die Minimierung der Summe der Fehlerquadrate: F(x) := i (y i (ax 2 i +bx i +c)) 2 min Details hören Sie in Statistik, 3. Semester mein Wahlpflichtfach Numerik für InformatikerInnen, 4. Semester Problem: Koeffizienten sind abhängig von Hard-/Software Lösung: Korrekturfaktoren für die Hard- und Softwareumgebung nur sehr eingeschränkt möglich. 11

12 Einführung (10) Messen der Laufzeit: Implementieren in einer konkreten Sprache/Compiler. Festgelegt bei Ausführung: Rechner/Eingabemenge. Probleme: Festlegen auf Norm nur schwer möglich. Ergebnisse lassen sich nur schwer übertragen. Aussage über Skalierung basiert auf Vermutung. Speicherbegrenzung: Paging/Swaping, Cache-Effekte Messen und Vergleichen der Laufzeiten ist oft nicht praktikabel oder sinnvoll! 12

13 Bewertung von Algorithmen (1) Ausweg: idealisiertes Modell (RAM: Random Access Machine) * Festgelegter Befehlssatz (Assembler-ähnlich) * abzählbar unendlich viele Speicherzellen Laufzeit: Anzahl ausgeführter RAM-Befehle Speicherbedarf: Anzahl benötigter Speicherzellen charakteristische Parameter ermitteln * Sortieren: Schlüsselvergleiche, Vertauschungen * Arithmetik: Additionen, Multiplikationen Mehr zu Maschinenmodellen und Komplexitätstheorie in der Vorlesung Theoretische Informatik (meine Vorlesung, 3. Semester) siehe z.b. The Art of Computer Programming, D.E.Knuth 13

14 Bewertung von Algorithmen (2) Laufzeit und Speicherbedarf sind in der Regel abhängig von der Größe der Eingabe. Warum ist die Komplexität der Algorithmen interessant? Beispiel: Traveling Salesperson Problem Gegeben: Eine Menge von Orten, die untereinander durch Wege verbunden sind. Die Wege sind unterschiedlich lang. Gesucht: Eine Rundreise, die durch alle Orte genau einmal führt und unter allen Rundreisen minimale Länge hat. (Tourenplanung) Bester bekannter Algorithmus: Laufzeit 2 n bei n Orten. Frage: Bis zu wie vielen Städten bekomme ich eine Lösung in einem Tag? 14

15 Bewertung von Algorithmen (3) Annahme: Rechengeschwindigkeit beträgt 1GOp/s: Schritte pro Sekunde Schritte pro Stunde Schritte pro Tag Lösbare Problemgröße am Tag: 46 Städte im Jahr: 55 Städte in 100 Jahren: 61 Städte in Deutschland: 5000 Städte 15

16 Bewertung von Algorithmen (4) Frage: Löst ein schnellerer Rechner das Problem??? Antwort: Nein! Annahme: Geschwindigkeit verdoppelte sich alle 1,5 Jahre (Vermutung nach Mooreschem Gesetz) in 10 Jahren: Lösbare Problemgröße am Tag: 52 Orte in 100 Jahren: Lösbare Problemgröße am Tag: 112 Orte Fortschritt nach 1,5 Jahren (Computer B): Computer Dauer Anzahl Schritte A 1 Tag 2 n B 1 Tag 2 2 n = 2 n+1 Die Touren sollen jetzt geplant werden, nicht in 100 Jahren! 16

17 Bewertung von Algorithmen (5) Lösung 1: bessere Algorithmen. Speed is fun! Laufzeit Dauer für 5000 Städte #Städte pro Tag n <1 Sekunde ( ) 1/ n Minuten ( ) 1/ n Tage ( ) 1/ n Jahre ( ) 1/5 612 Frage: Gibt es bessere Algorithmen für das Problem??? Es gibt ein Preisgeld von $ für einen Algorithmus, dessen Laufzeit für dieses Problem ein Polynom in der Anzahl der Städte ist. Es gibt ständig neue Fast-Beweise. 17

18 Bewertung von Algorithmen (6) Lösung 2: parallele/verteilte Systeme Problem auf mehreren Prozessoren/Computern gleichzeitig bearbeiten Verteilte/Parallele Systeme (meine Vorlesung 1. Master-Semester, Parallel Computing) Lösbare Problemgröße am Tag bei linearem Speedup, also Rechenzeit halbiert sich bei doppelter Anzahl von Rechenkernen. #Rechnenkerne TSP 2 n Matrixmultiplikation n Der weltschnellste Rechner hat heute (Liste Nov. 2016) Kerne 18

19 Asymptotische Komplexität (1) Genaue Angabe der Komplexitätsfunktion ist oft schwierig oder unmöglich. Unscharfe Aussagen: Abstrahieren von additiven Konstanten, konstanten Faktoren und Termen niedrigerer Ordnung. Beispiel: 7 log 2 (n)+5 n 3 +3 n 4 7 n 4 +5 n 4 +3 n 4 15 n 4 n 4 19

20 Asymptotische Komplexität (2) Dürfen Terme niedriger Ordnung vernachlässigt werden? Betrachten wir dazu die folgenden Funktionen: f 1 (x) = x 2 f 2 (x) = x 2 17 x log 2 (x) 139 x 1378 f 3 (x) = x x log 2 (x)+241 x e+08 1e+07 1e+06 f(x) f 1 (x) f 2 (x) f 3 (x) x 20

21 Asymptotische Komplexität (3) Anmerkungen: Bei kleinen Eingabegrößen sind die konstanten Faktoren und Terme niedriger Ordnung entscheidend Große multiplikative Konstanten: theoretisch gute Lösungen, manchmal nicht akzeptabel Hard-/Software-abhängige Konstanten fallen nicht mehr ins Gewicht 21

22 Aufwandsklassen (1) Definition: Sei g : N 0 R + eine Funktion. Dann bezeichnet O(g) die Menge der Funktionen, die asymptotisch höchstens so stark wachsen wie g. f(n) O(g) = {f : N 0 R + c R,c > 0 : lim n g(n) c} g ist proportional zu einer oberen Schranke für große n! Wir schreiben: O(n) für O(g) falls g(n) = n O(n k ) für O(g) falls g(n) = n k O(log(n)) für O(g) falls g(n) = log(n) O( n) für O(g) falls g(n) = n O(2 n ) für O(g) falls g(n) = 2 n Wir werden eine allgemeinere Definition in THK kennen lernen, die auch Funktionen einschließt, die keinen Grenzwert haben. 22

23 Aufwandsklassen (2) Beispiele: 2 n n 3 O(n 3 ) 2 n n 3 O(n 4 ) 2 n n 3 O(n 2 ) 42 n log(n)+3 n 2 O(n 2 ) 17 n+139 n O(n) 17 n+139 n O(log(n)) 928 n n O(2 n ) c 1 n+c 2 n c k n k O(n k ) für c 1,...,c k konstant 23

24 Aufwandsklassen (3) Definition: Sei g : N 0 R + eine Funktion. Dann bezeichnet Ω(g) die Menge der Funktionen, die asymptotisch mindestens so stark wachsen wie g. g ist proportional zu einer unteren Schranke für große n! g(n) Ω(g) = {f : N 0 R + c R,c > 0 : lim n f(n) c} Beispiele: 2 n n 3 Ω(n 3 ) 2 n n 3 Ω(n 2 ) 2 n n 3 Ω(n 4 ) 42 n log(n)+3 n 2 Ω(n) 17 n+139 n Ω(n) c 1 n+c 2 n c k n k Ω(n k ) für c 1,...,c k konstant 24

25 Aufwandsklassen (4) Definition: Sei g : N 0 R + eine Funktion. Dann bezeichnet Θ(g) die Menge der Funktionen, die asymptotisch genauso stark wie g wachsen. Beispiele: Θ(g) = {f : N 0 R + f O(g) f Ω(g)} 2 n n 3 Θ(n 3 ) 42 n log(n)+3 n 2 Θ(n 2 ) 17 n+139 n Θ(n) 928 n n Θ(2 n ) c 1 n+c 2 n c k n k Θ(n k ) für c 1,...,c k konstant 25

26 Aufwandsklassen (5) Wichtige Aufwandsklassen: O(1) konstant O(n 2 ) quadratisch O(log(n)) logarithmisch O(n 3 ) kubisch O(log k (n)) poly-logarithmisch O(n k ) polynomiell O(n) linear O(2 n ) exponentiell O(n log(n)) Inklusionen der wichtigsten Aufwandsklassen: O(1) O(log(n)) O(log 2 (n)) O( n) O(n) O(n log(n)) O(n 2 ) O(n 3 ) O(2 n ) 26

27 Vergleich der Aufwandsklassen (1) f(n) 100 e n n 3 n 2 n log(n) n 27

28 Vergleich der Aufwandsklassen (2) GOp/sec n 2 n 3 n 4 e n = O(n 2 ): n 1 = 1e9 = n 2 = 1e10 = 1e9 10 = n 1 10 O(e n ): n 1 = ln(1e9) = n 2 = ln(1e10) = ln(1e9)+ln(10) = n 1 +ln(10) 28

29 Vergleich der Aufwandsklassen (3) Annahme: Schritte pro Sekunde. Lösbare Problemgröße bei verschiedenen Zeitvorgaben: Aufwand 1 Sek 1 Min 1 Std 1 Tag n n n n e n

30 Komplexitätsmaße (1) Bei einigen Problemen hängt die Laufzeit nicht nur von der Menge der Eingabewerte ab, sondern auch von der Reihenfolge der Werte. Man unterscheidet die Laufzeit im besten Fall (best case) im Mittel (average case) im schlechtesten Fall (worst case) Vergleich: Lineare Suche vs. binäre Suche Algorithmus best case average case worst case lineare Suche 1 N/2 N binäre Suche 1 log 2 (N) log 2 (N) 30

31 Komplexitätsmaße (2) Probleme bei average case: Worüber bildet man den Durchschnitt? Sind alle Eingaben der Länge N gleich wahrscheinlich (Gleichverteilung, wird meist nur betrachtet)? Technisch oft sehr viel schwieriger durchzuführen als worst-case Analyse. Murphys Gesetz: Alles was schief gehen kann, wird auch schief gehen. Immer wenn ich das Programm ausführe, warte ich ewig. Ungeeignet für kritische Anwendungen, bei denen maximale Reaktionszeiten garantiert werden müssen Echtzeitsysteme (Dr. Quade) 31

32 Worst-Case Komplexität Definition: (Worst-Case Komplexität) W n : Menge der zulässigen Eingaben der Länge n. A(w): Anzahl Schritte von Algorithmus A für Eingabe w. Worst-Case Komplexität (schlechteste Fall): T A (n) = sup{a(w) w W n } ist eine obere Schranke für die maximale Anzahl der Schritte, die Algorithmus A benötigt, um Eingaben der Größe n zu bearbeiten. 32

33 Worst-Case Komplexität: Beispiel lineare Suche: binäre Suche: N log(n)..... Zum Vergleich: N log(n)

34 Average-Case Komplexität Definition: (Average-Case Komplexität) W n : Menge der zulässigen Eingaben der Länge n. A(w): Anzahl Schritte von Algorithmus A für Eingabe w. Average-Case Komplexität (erwarteter Aufwand): T A (n) = 1 W n w W n A(w) ist die mittlere Anzahl von Schritten, die Algorithmus A benötigt, um eine Eingabe der Größe n zu bearbeiten. Wir setzen hier eine Gleichverteilung voraus arithmetischer Mittelwert 34

35 Average-Case Komplexität: Beispiel (1) lineare Suche: Kosten: erwartete Kosten: 1,...,N Vergleiche 1 N ( N) 1/N (1+N) 1/N (2+N 1) 1/N (3+N 2)..... N/2 1 N ( N) = 1 N N(N +1) 2 = N

36 Average-Case Komplexität: Beispiel (2) binäre Suche: Kosten: 1,...,log(N) zur Vereinfachung: N = 2 x 1 erwartete Kosten: 1 N ( x 1 x) 1/N * 1 2/N * 2 4/N * 3 log(n) 8/N * 4 36

37 Average-Case Komplexität: Beispiel (3) Behauptung (Induktionsvermutung IV): x i=1 i 2 i 1 = (x 1) 2 x +1 Beweis mittels vollständiger Induktion: Induktionsanfang: x = 1 Induktionsschritt: x x+1: x+1 i= = 1 1 = 1! = = 1 i 2 i 1 = x i=1 i 2 i 1 + (x+1) 2 x IV = (x 1) 2 x +1 + (x+1) 2 x = 2x 2 x +1 = x 2 x

38 Average-Case Komplexität: Beispiel (4) Aus der Annahme N = 2 x 1 folgt: log 2 (N +1) = x Somit ergibt sich: 1 N x i=1 i 2 i 1 = 1 N [(x 1) 2x +1] = 1 N [(log 2(N +1) 1) (N +1)+1] = 1 N [(N +1) log 2(N +1) N] log 2 (N +1) 1 für große N Im Mittel verursacht binäres Suchen also nur etwa eine Kosteneinheit weniger als im schlechtesten Fall. 38

39 Entwurfsmethoden Neben vielen Einzellösungen gibt es Entwurfsprinzipien, die einen Algorithmusentwurf erleichtern können. Hier hauptsächlich nur Divide and Conquer Algorithmen (Teile und Herrsche) Greedy Algorithmen (gierig) In der Veranstaltung Effiziente Algorithmen, Masterstudiengang gibt es viele weitere Entwurfsmethoden wie z.b. Dynamisches Programmieren: Speichere bereits berechnete Teillösungen in einer Tabelle. Diese Technik nennt man Memorieren und setzte daraus die Gesamtlösung zusammen, hier nur das Beispiel des Algorithmus von Floyd und Warshall. Lokale Suche... 39

40 Divide & Conquer Divide & Conquer ist ein Entwurfsprinzip für Algorithmen mit vielfältigen Anwendungen Entwurfsprinzip: Divide the problem into subproblems. Conquer the subproblems by solving them recursively. Combine subproblem solutions. Beispiele: Binäre Suche Potenzieren einer Zahl Matrix-Multiplikation Quicksort (der Sortieralgorithmus der C-Bibliothek) 40

41 Divide & Conquer: Potenzieren einer Zahl (1) Problem: Berechne x n für ein n N. Einfacher Algorithmus: erg := 1 for i := 1 to n do erg := erg * x Laufzeit: Θ(n) Multiplikationen Divide & Conquer: x n = x n/2 x n/2 für n gerade und > 1 x (n+1)/2 x (n 1)/2 für n ungerade und > 1 x für n = 1 1 für n = 0 41

42 Divide & Conquer: Potenzieren einer Zahl (2) Der Exponent wird in jedem Schritt ungefähr halbiert. Eine obere Schranke für die Laufzeit ergibt sich, wenn der Exponent auf die nächst höhere 2er-Potenz erhöht wird. Dann gilt: T(n) = T(n/2)+Θ(1) = (T(n/4)+Θ(1))+Θ(1) = T(1)+log(n) Θ(1) = Θ(log(n)), falls jede Multiplikation gleich lang dauert (analog zur binären Suche). 42

43 Divide & Conquer: Matrix-Multiplikation (1) Eingabe: zwei n n-matrizen A und B Ausgabe: C = A B Es gilt: c 11 c 12 c 1n c 21 c 22 c 2n = a 11 a 12 a 1n a 21 a 22 a 2n b 11 b 12 b 1n b 21 b 22 b 2n c n1 c n2 c nn a n1 a n2 a nn b n1 b n2 b nn mit der Formel c ij = n k=1 a ik b kj 43

44 Divide & Conquer: Matrix-Multiplikation (2) Einfacher Algorithmus: for i := 1 to n do for j := 1 to n do c[i][j] := 0 for k := 1 to n do c[i][j] := c[i][j] + a[i][k] * b[k][j] Laufzeit: Θ(n 3 ) Additionen/Multiplikationen 44

45 Divide & Conquer: Matrix-Multiplikation (3) Aufteilen der n n-matrizen in jeweils vier n 2 n 2 -Matrizen: mit ( r s t u ) = ( a b c d ) ( e f g h C = A B ) r = ae+bg s = af +bh t = ce+dg u = cf +dh 8 Multiplikationen von n 2 n 2 -Matrizen 4 Additionen von n 2 n 2 -Matrizen Laufzeit: T(n) = 8 T(n/2)+4 (n/2) 2 45

46 Divide & Conquer: Matrix-Multiplikation (4) Löse die Gleichung rekursiv durch Einsetzen T(n) = 8 T( n 2 )+n2 = 8 [ 8 T( n 2 2)+ ( n 2 ) 2 ] +n 2 = 8 2 T( n 2 2)+(2+1) n2 = 8 3 T( n 2 3)+(4+2+1) n2 =... = 8 k T( n 2 k)+ k 1 2 i i=0 n 2 = 8 k T( n 2 k)+(2k 1) n 2 46

47 Divide & Conquer: Matrix-Multiplikation (5) Führe die Rekursion durch bis 2 k = n oder k = log 2 n T(n) = 8 k T( n 2 k)+(2k 1) n 2 = 8 log2n T(1)+(n 1) n 2 = n 3 +(n 1) n 2 mit T(1) = 1 Θ(n 3 ) mit 8 log 2n = (2 3 ) log 2n = 2 3 log 2n = (2 log 2n ) 3 = n 3 Leider nichts gewonnen! 47

48 Matrix-Multiplikation: Strassens Idee (1) Strassen 1969: ( r s t u ) = ( a b c d ) ( e f g h ) mit P 1 = a (f h) P 2 = (a+b) h P 3 = (c+d) e P 4 = d (g e) P 5 = (a+d) (e+h) P 6 = (b d) (g +h) P 7 = (a c) (e+f) und r = P 5 +P 4 P 2 +P 6 s = P 1 +P 2 t = P 3 +P 4 u = P 5 +P 1 P 3 P 7 Laufzeit: T(n) = 7T ( n 2 ) +18 ( n2 ) 2 Θ(n log 2 7 ) Θ(n ) 48

49 Matrix-Multiplikation: Strassens Idee (2) Vergleich der Laufzeiten: (Annahme 1 GOp/s) n n 3 time n time n time e9 1 s 2.64e8 1 s 1.55e7 1 s e12 16 m 1.70e11 3 m 3.87e9 4 s e15 11 t 1.09e14 2 t 9.66e11 16 m e18 31 j 9.98e16 3 j 2.41e14 3 t s: Sekunden, m: Minuten t: Tage, j: Jahre Coppersmith und Winograd 1982: O(n ) 49

50 Rekursionsgleichungen (1) Laufzeit bei der Unterteilung in k Teile: { c ; falls n n0 T(n) = T(n 1 )+...+T(n k )+Combine-Aufwand; sonst Für gleich große Teile: T(n) = a T(n/b)+Θ(n k ) Das Master-Theorem gibt die Lösung dieser Gleichung an. Unterscheide drei Fälle: für a < b k gilt: T(n) = Θ(n k ) für a = b k gilt: T(n) = Θ(n k log(n)) für a > b k gilt: T(n) = Θ(n log ba ) 50

51 Rekursionsgleichungen (2) Beispiele: Binäre Suche: T(n) = T(n/2)+Θ(1), also a = 1, b = 2, k = 0 a = b k T(n) = Θ(n k log(n)) = Θ(log(n)) Matrix-Multiplikation (Standard): T(n) = 8 T(n/2)+4 (n/2) 2 also a = 8, b = 2, k = 2 a > b k T(n) = Θ(n log ba ) = Θ(n 3 ) Matrix-Multiplikation (Strassen): T(n) = 7T ( n 2 ) +18 ( n2 ) 2 also a = 7, b = 2, k = 2 a > b k T(n) = Θ(n log ba ) = Θ(n ) 51

52 Strassen-Algorithmus Ab wann lohnt sich der Strassen-Algorithmus? Lösung der Rekursionsgleichung durch Iteration mit allen Vorfaktoren ( ) n T(n) = 7T ,2 n ( ) n 2 2 Strassen lohnt sich ab n > Wenn für Matrixgrößen 36 zur Standardmethode gewechselt wird, reduziert sich der Vorfaktor von 28,2 auf 4,61. Das gemischte Verfahren lohnt sich bereits ab Matrizen mit den Größen n 80. Beweis in Heun 52

53 Greedy-Algorithmen (1) Greedy (gierigen) Algorithmen sind geeignet, um Optimierungsprobleme zu lösen oder zu approximieren. Es wird zwischen exakten Greedy-Algorithmen und Greedy-Heuristiken unterschieden. Beispiele Das Wechselgeldproblem (exakt oder approximativ) Kürzeste Wege (exakt) Minimaler Spannbaum (exakt) Strategien für das TSP-Problems (approximativ) 53

54 Greedy-Algorithmen (2) Vorgehen: Jeder Schritt wird nur aufgrund der lokal verfügbaren Information durchgeführt. Es wird aus allen möglichen Fortsetzungen einer Teillösung diejenige ausgewählt, die momentan den besten Erfolg bringt. Beispiel: Das Wechselgeldproblem Aufgabe: Herausgabe von Wechselgeld mit möglichst wenig Münzen verfügbare Münzen mit Werten zu 50, 20, 10, 5, 2, 1 Cent Ziel: gebe z.b. 78 Cent zurück mit so wenig Münzen wie möglich 78 Cent = Münzen 54

55 Greedy-Algorithmen (3) Algorithmus: 1. Nehme immer die größte Münze unter Zielwert, und ziehe sie von diesem ab. 2. Verfahre derart bis Zielwert gleich Null. Greedy-Algorithmen berechnen in jedem Schritt lokales Optimum Ohne Beweis: Für unsere Münzwerte ist der Greedy-Algorithmus exakt, d.h. lokale Optimum = globales Optimum 55

56 Greedy-Algorithmen (3) Oft kann das globale Optimum verfehlt werden! Beispiel: Münzen: 11, 5, und 1 Zielwert 15 Greedy: Münzen aber Optimum: Münzen aber: in vielen Fällen reicht ein lokales Optimum aus! Komplexität meist: Auswertung der lokalen Information Durchführung des nächsten Schritts n 56