Informatik I 1. Kapitel. Einführung in Algorithmen und Datenstrukturen. Einführung in Algorithmen. Einführung in Algorithmen.

Transkript

1 Informatik I 1. Kapitel Rainer Schrader Einführung in Algorithmen und Datenstrukturen Zentrum für Angewandte Informatik Köln 16. Juli / 1 / 1 Einführung in Algorithmen Einführung in Algorithmen Gliederung Algorithmen Laufzeitanalyse Laufzeitschranken Beispiel: das Maximum-Subarray-Problem Algorithmus Folge von exakten Arbeitsanweisungen (zum Lösen einer Rechenaufgabe) in endlich vielen, eindeutig festgelegten, auch wiederholbaren Schritten. (ZEIT-Lexikon) 3 / 1 4 / 1

2 Algorithmus Rechenvorschrift Programme konkrete Formulierungen abstrakter Algorithmen, Eingabe Berechnung Ausgabe die bestimmte Darstellungen und Datenstrukturen verwenden (Wirth) Jede mit einem Algorithmus lösbare Aufgabe kann prinzipiell auch von einem Rechenautomat gelöst werden. (ZEIT-Lexikon) Programmerstellung und Datenstrukturierung sind untrennbare, ineinandergreifende Themen 5 / 1 6 / 1 Einführung Bemerkung zu Programmen Programme werden in einer abstrahierenden Programmiersprache beschrieben: keine Deklarationen if-then-else for-schleifen while-schleifen höhere Konstrukte Compiler spricht auch deutsch... Beispiel: Sortierproblem Eingabe: Eine Folge von n Zahlen a 1, a,..., a n Ausgabe: Eine Permutation (Umordnung) a 1, a,..., a n der Eingabefolge, so dass gilt: a 1 a... a n. 7 / 1 8 / 1

3 jede konkrete Zahlenfolge ist eine Instanz des Sortierproblems z.b. soll 3, 5, 13, 48, 39 in 13, 5, 3, 39, 48 überführt werden Sortieren ist eine grundlegende Operation in der Informatik unterschiedliche Algorithmen erweisen sich je nach Szenario als mehr oder weniger geeignet: wie viele Elemente? kann die Natur der Elemente ausgenützt werden? ist schon teilweise sortiert? im Hauptspeicher, auf Platte? wir wollen versuchen, das jeweilige Verhalten zu analysieren 9 / 1 10 / 1 Sprechweisen: eine Instanz eines Problems besteht aus allen Eingabewerten, die zur Lösung benötigt werden ein Algorithmus heißt korrekt, wenn seine Ausführung für jede mögliche Eingabeinstanz mit der korrekten Ausgabe beendet wird ein korrekter Algorithmus löst das gegebene Problem. Spezifikation eines Algorithmus: ein Algorithmus kann auf verschiedene Art und Weise spezifiziert werden: auf Deutsch, Englisch,... als Hardwaredesign als Computerprogramm (Gegenstand der Informatik I) Wir veranschaulichen den letzten Punkt an einem Sortier-Algorithmus. 11 / 1 1 / 1

4 A[1] A[] A[3] A[4] A[5] A[6] Sortieren durch Einfügen (insertion sort) Idee: Sortieren von Spielkarten füge das i-te Eingabeelement in die bereits sortierte Liste der ersten i 1 Elemente ein / 1 14 / 1 1. for j= to n do. key = A(j) füge A(j) in die sortierte Folge A(1...j-1) ein 4. i = j while (i > 0 und A(i) > key) do 6. A(i+1) = A(i) 7. i = i-1 end while 8. A(i+1) = key end do Ablauf auf der Eingabefolge 5,, 4, 6, 1, 3 : A(1) A() A(3) A(4) A(5) A(6) / 1 16 / 1

5 natürliche Fragestellungen an einen Algorithmus: ist der Algorithmus korrekt? welche Ressourcen verbraucht der Algorithmus? logische Schaltungen Kommunikationsbandbreite Speicherplatz Zeit Gliederung Algorithmen Laufzeitanalyse Laufzeitschranken Beispiel: das Maximum-Subarray-Problem 17 / 1 18 / 1 wir sind im folgenden fast immer an der Zeit interessiert aber auf welcher Maschine wird die Zeit verbraucht? intuitiv am Beispiel des Sortierproblems: wir betrachten eine idealisierte Maschine: RAM: random access machine mit folgenden Eigenschaften: 1 Prozessor alle Daten im Hauptspeicher die Datenzugriffe dauern alle gleich lange das Sortieren von 1000 Zahlen dauert länger als das Sortieren von 10 Zahlen, bei gleich langen Folgen geht es für fast sortierte schneller wir beschreiben die Laufzeit als Funktion der Eingabegröße beim Sortieren als Funktion von n = Anzahl der zu sortierenden Zahlen 19 / 1 0 / 1

6 Kosten von insertion_sort wir zählen die Anzahl der primitiven Operationen (Rechenschritte), hier vereinfachend: jeder Programmbefehl benötigt konstante Zeit Im Beispiel insertion_sort: sei t j die Anzahl der Durchläufe der while-schleife für Index j entspricht der Anzahl der Positionen, um die Element j verschoben wird 1.for j= to n do. key = A(j) füge A(j) ein 3. i = j while(i>0 & A(i)>key) do 5. A(i+1) = A(i) 6. i = i-1 end while 7. A(i+1) = key end do Zeile Kosten wie oft? 1 c 1 n c n 1 3 c 3 n P 1 4 c n 4 j= t j P 5 c n 5 j= (t j 1) P 6 c n 6 j= (t j 1) 7 c 7 n 1 1 / 1 / 1 Gesamtlaufzeit: Zeile Kosten wie oft? 1 c 1 n c n 1 3 c 3 n P 1 4 c n 4 j= t j P 5 c n 5 j= (t j 1) P 6 c n 6 j= (t j 1) 7 c 7 n 1 T (n) = c 1 n + c (n 1) + c 3 (n 1) + c 4 n j= n n + c 5 (t j 1) + c 6 (t j 1) + c 7 (n 1) j= j= t j Bester Fall: Die Eingabefolge ist bereits sortiert in Zeile 4 ist dann immer A(i) key somit t j = 1 für j =, 3,... n, deshalb T (n) = c 1 n + c (n 1) + c 3 (n 1) + c 4 + c 6 (t j 1) + c 7 (n 1) j= t j + c 5 (t j 1) = c 1 n + c (n 1) + c 3 (n 1) + c 4 (n 1) + c 7 (n 1) = (c 1 + c + c 3 + c 4 + c 7 )n (c + c 3 + c 4 + c 7 ) = an + b für Konstanten a und b, lineare Funktion in n. j= j= 3 / 1 4 / 1

7 Schlechtester Fall: Die Eingabefolge ist in umgekehrter Reihenfolge sortiert. hier gilt t j = j für j =, 3,..., n, deshalb T (n) = c 1 n + c (n 1) + c 3 (n 1) + c 4 + c 6 (t j 1) + c 7 (n 1) j= t j + c 5 j= (t j 1) n(n + 1) = c 1 n + c (n 1) + c 3 (n 1) + c 4 «n(n 1) + c 6 + c 7 (n 1) c4 = + c 5 + c 6 n + c 1 + c + c 3 + c 4 c 5 c 6 + c 7 (c + c 3 + c 4 + c 7 ) = an + bn + c für Konstanten a, b und c, j= ««n(n 1) 1 + c 5 n worst-case Laufzeit die längste mögliche Laufzeit bei vorgegebener Eingabegröße der Instanz, eine obere Schranke für die Laufzeit einer beliebigen Instanz dieser Größe Bei manchen Problemen kann der worst-case oft auftreten, z.b. bei der Suche eines nicht vorhandenen Eintrags in einer Datenbank. quadratische Funktion in n. 5 / 1 6 / 1 average-case Laufzeit ist die durchschnittliche Laufzeit über alle Instanzen der Größe n (einer gegebenen Instanzklasse), kann manchmal erheblich besser als der worst case sein kann aber auch genauso schlecht wie der worst case sein (beim Sortieren durch Einfügen führt t j = j quadratischen Laufzeitfunktion T (n).) das Problem beim average case ist: auch zu einer Vereinfachung wir werden uns von der mühsamen Berechnung der Konstanten frei machen wir werden nur die Ordnung der Laufzeit betrachten, also an + bn + c = Θ(n ) darauf gehen wir später präziser ein an + b = Θ(n) Was ist eine durchschnittliche Eingabe? 7 / 1 8 / 1

8 Sortieren durch Einfügen benutzt inkrementellen Ansatz ein anderer Ansatz ist Sortierung durch Verschmelzen (merge sort) teile und erobere divide and conquer teile das Problem in Teilprobleme auf erobere die Teilprobleme durch rekursives Lösen (wenn sie klein genug sind, löse sie direkt) kombiniere die Lösungen der Teilprobleme zu einer Lösung des Gesamtproblems teile: teile die n-elementige Folge in der Mitte in zwei Teilfolgen, erobere: sortiere beide Teilfolgen rekursiv mit merge sort, kombiniere: verschmelze die beiden Teilfolgen zu einer sortierten Gesamtfolge Bemerkung: Für einelementige Teilfolgen ist nichts zu tun. Wir veranschaulichen diesen Ansatz wiederum an einem Sortieralgorithmus. 9 / 1 30 / 1 Grobkonzept von merge sort A : Array p,q, r : Indizes mit p q r. merge(a,p,q,r) verschmilzt die beiden bereits sortierten Teilarrays A(p..q) und A(q+1..r) sortiertes Array A(p..r) Laufzeit beträgt Θ(r p + 1) (Übungsaufgabe) merge_sort merge_sort(a,p,r) if (p < r) then do q = (p+r)/ merge_sort(a,p,q) merge_sort(a,q+1,r) merge(a,p,q,r) merge_sort(a,p,r) sortiert A(p..r) falls p r gilt, so ist nichts zu tun Sortieren eines n-elementigen Arrays durch merge_sort(a,1,n). end end if 31 / 1 3 / 1

9 Illustration: Eingabefolge Ausgabefolge Analyse der worst-case-laufzeit Vereinfachende Annahme: n = k für k 1. gesucht: Laufzeit T (n). Teile: Bestimmung der Mitte des Arrays in konstanter Zeit D(n) = c 1. Erobere: Lösen zweier Teilprobleme der Größe n Kombiniere: wie diskutiert C(n) = c n. j c für n = 1 insgesamt: T (n) T ( n ) + cn für n > 1 mit c = max{c 1, c }. Behauptung: T (n) cn log n + cn und damit besser als Sortieren durch Einfügen. in T ( n ) Zeit. 33 / 1 34 / 1 Behauptung: T (n) cn log n + cn = cn log n + cn. Beweis per Induktion: T (1) c = c c 1 = c 1 log 1 + c 1 Bedeutung in der Praxis Wettbewerb im Sortieren von Zahlen Teilnehmer: ein Hochleistungsrechner mit einem schlechten Programm ein PC mit einem guten Programm T (n) T ( n ) + cn [c n log n + c n ] + cn = cn log n + cn = cn log n cn log + cn = cn log n cn + cn = cn log n + cn Damit folgt: T (n) cn log n + cn. (per Induktion) Algorithmus Implementierung Geschwindigkeit Supercomputer insertion_sort n 10 1 Op./s (1 Teraflop) PC merge_sort 50n log n 10 9 Op./s (1 Gigaflop) 35 / 1 36 / 1

10 Algorithmus Implementierung Geschwindigkeit Supercomputer insertion_sort n 10 1 Op./s (1 Teraflop) PC merge_sort 50n log n 10 9 Op./s (1 Gigaflop) Zeitbedarf: Supercomputer: ( ) Operationen 10 1 Operationen/sec = 1800 sec 3.5 h Gliederung Algorithmen Laufzeitanalyse Laufzeitschranken Beispiel: das Maximum-Subarray-Problem PC: log ( ) Operationen 10 9 Operationen/sec. 105 sec Wie Hardware sind auch Algorithmen Technologie 37 / 1 38 / 1 Wir wollen das qualitative Wachstum der Laufzeit eines Algorithmus ausdrücken: sei dazu f : N 0 R die Laufzeitfunktion sei g : N 0 R eine Vergleichsfunktion wir wollen ausdrücken: f wächst höchstens so schnell wie g f wächst mindestens so schnell wie g f wächst wie g Sei g : N 0 R eine Funktion. Wir definieren die folgenden Mengen von Funktionen: O(g(n)) := {f (n) : f (n) cg(n)} für alle n n 0. Ω(g(n)) := {f (n) : cg(n) f (n)} für alle n n 0. Θ(g(n)) := {f (n) : cg(n) f (n) dg(n)} für alle n n 0. jeweils für geeignete Konstanten c, d, n 0 > 0 (genauer: zu jedem f existieren Konstanten ). 39 / 1 40 / 1

11 Illustration: Schreibweise: c g(n) anstelle von f (n) Θ(g(n)) schreiben wir f (n) = Θ(g(n)) f(n) n0 c1 g(n) n entsprechend f (n) = Ω(g(n)) und f (n) = O(g(n)) wir benutzen die Notationen O für obere Schranken, Ω für untere Schranken, Θ für die genaue Bestimmung der Wachstumsrate. 41 / 1 4 / 1 Beispiel: Beispiel: zu zeigen: 1 n 3n = Θ(n ). es existieren Konstanten c 1, c und n 0, so dass c 1 n 1 n 3n c n für alle n n 0. Mit Division durch n (1) > 0 erhalten wir c () c n. (1) gilt für alle n 7, wenn c () gilt für alle n 1, wenn c 1. Also wähle z.b. c 1 = 1 14, c = 1 und n 0 = 7. 6n 3 Θ(n ) Annahme: es gibt Konstanten c, n 0, so dass 6n 3 c n für alle n n 0. Dann folgt: n c 6 für alle n n 0 Allgemein gilt: an + bn + c = Θ(n ). Beweis als Übungsaufgabe. 43 / 1 44 / 1

12 Beispiel: insertion_sort: Beispiel Für jede Konstante c gilt: c = Θ(1). zu zeigen: es existieren Konstanten c 1, c und n 0, so dass c 1 1 c c 1 für alle n n 0. wähle c 1 = c = c und n 0 = 1. worst case Laufzeit O(n ): ergibt sich aus der Doppelschleife impliziert Laufzeit von O(n ) für beliebige Eingaben die worst case Laufzeit Θ(n ) impliziert nicht eine Laufzeit Θ(n ) für beliebige Eingaben: ist die Eingabe bereits sortiert: Laufzeit Θ(n) eine best case Laufzeit Ω(n) impliziert eine Laufzeit Ω(n) für beliebige Eingaben. 45 / 1 46 / 1 Weitere Schreibweisen: Beispiel n + 3n + 1 = n + Θ(n) Beispiel n + Θ(n) = Θ(n ) Interpretation: es gibt eine Funktion f (n) Θ(n) mit n + 3n + 1 = n + f (n) (wähle f (n) = 3n + 1). Interpretation: für alle f (n) Θ(n) existiert ein g(n) Θ(n ) so, dass n + f (n) = g(n) für alle n (wähle g(n) = n + f (n)). 47 / 1 48 / 1

13 Um von einem speziellen Computer unabhängig zu sein, zählen wir Entwarnung: wir werden fast auschließlich obere Schranken berechnen einfache Funktionen dafür verwenden: O(n), O(n ), O(n 3 ),, O(n k ) O(n log n), O(n log n), Elementaroperationen: Zuweisungen a = b, arithmetische Befehle a = b c mit {+,-,*,/,%,...}, logische Operationen und, oder, neg,... und Sprungbefehle goto label; if a b...; else...; mit { <, <=, ==,!=, >=, >} 49 / 1 50 / 1 Vereinfachende Annahme jede Elementaroperation benötigt eine Zeiteinheit wir vernachlässigen also: die Indexrechnungen, den Typ der Operanden und die Länge der Operanden for- und while-schleifen if <Bedingung> <Anweisung1> else <Anweisung> Kosten := j Kosten(Bedingung) + Kosten(Anweisung1) Kosten(Bedingung) + Kosten(Anweisung) while <Bedingung> <Anweisung> for <Schleife> do <Anweisung> end do Kosten: die wiederholten Kosten für Test auf Bedingung bzw. Schleifenende und (1 weniger) die Kosten der Anweisung. 51 / 1 5 / 1

14 Maximum-Subarray-Problem gegeben: eine Folge von n ganzen Zahlen in einem Array gesucht: Gliederung Algorithmen Laufzeitanalyse Laufzeitschranken Beispiel: das Maximum-Subarray-Problem eine zusammenhängenden Teilfolge, deren Summe maximal ist. (Die Teilfolge kann auch leer sein.) Beispiel: {z } Wert 187 ist maximal / 1 54 / 1 1. Versuch: naiver Ansatz 1. Versuch: naiver Ansatz berechne für jedes Teilintervall die Summe der Einträge unter all diesen Summen wähle das Maximum 55 / 1 56 / 1

15 1. Versuch: naiver Ansatz Laufzeitanalyse des naiven Ansatzes maxteilsumme = 0 for li = 1 to n do for re = li to n do // bestimme Summe in der Teilfolge X[li,...,re] summe = 0 for i = li to re do summe = summe + X(i) end do // schreibe Maximum fort if (summe > maxteilsumme) maxteilsumme = summe end do end do return maxteilsumme T (n) = = = = rx 1 l=1 r =l i=l l=1 r =l l=1 l=1 = Θ(n 3 ) (r l + 1) n l+1 X i=1 i 1 (n l + 1)(n l + ) 57 / 1 58 / 1 Versuch 1a: ein etwas weniger naiver Ansatz Versuch 1a: ein etwas weniger naiver Ansatz wir berechnen die Intervallsumme stets neu sie kann jedoch einfach fortgeschrieben werden dies reduziert die Laufzeit auf O(n ) maxteilsumme = 0 for li = 1 to n do summe = 0 for re = li to n do summe = summe + X(i) // schreibe Maximum fort if (summe > maxteilsumme) maxteilsumme = summe end do end do return maxteilsumme 59 / 1 60 / 1

16 . Versuch: Divide and Conquer wird die Folge in der Mitte geteilt, so gilt für eine maximale Teilfolge MT : sei MT = (l,..., re) sei m der mittlere Index im Fall () gilt : (1) entweder liegt MT ganz in einem der beiden Teile () oder MT umfasst die Trennstelle. (l,..., m) ist eine größte Teilfolge im linken Intervall, die m enthält (m,..., re) ist eine größte Teilfolge im rechten Intervall, die m enthält. Versuch: Divide and Conquer wir verwenden zwei Prozeduren: rightmax(x, l, r ) berechnet im Intervall [l, r ] eine maximale Teilfolge, die l enthält leftmax(x, l, r ) berechnet im Intervall [l, r ] eine maximale Teilfolge, die r enthält 61 / 1 6 / 1 Bestimmung des rechten Maximums in (l..r ) Divide-and-conquer procedure rightmax(x,le,re) rmax = 0 summe = 0 for i = le to re do summe = summe + X(i) if (summe > rmax) rmax = summe end do return rmax end procedure benötigt Θ(r l) Zeit leftmax(x, l, r ) analog procedure msp(x,le,re) if re = le then teilmax = X(le) else do m = (le+re)/ // halbiere Intervall mtsl = msp(x,le,m) mtsr = msp(x,m+1,re) // berechne das Maximum im // linken und rechten Intervall lmax = leftmax(x,le,m) // bestimme linke Teilfolge rmax = rightmax(m,re) // bestimme rechte Teilfolge teilmax = maximum {mtsl, mtsr, lmax+rmax-x(m)} end if return teilmax end procedure 63 / 1 64 / 1

17 Sei T (n) die worst-case-laufzeit. Dann gilt: wir wissen: j a für n = 1 T (n) T ` ˇ ` n + T n + an für n > 1 Satz j Θ(1) für n = 1 T (n) = T ` ˇ ` n + T n + Θ(n) für n > 1 Für die obige Rekursion gilt T (n) = Θ(n log n). wir zeigen per Induktion: für n 3 und c = 3a gilt T (n) cn log(n 1) Beweis: wir zeigen T (n) = O(n log n) es gilt auch T (n) = Ω(n log n) (Übungsaufgabe) die Fälle n = 3, 4, 5 zeigt man explizit wir führen nur den allgemeinen Fall n 6 vor 65 / 1 66 / 1 der Fall n = 3 : der Fall n = 4 : T (3) T (1) + T () + 3a (da T () T (1) + T (1) + a) 3T (1) + 5a 8a (da T (1) a) = 8 c (da c = 3a) 3 3c = c 3 log(3 1) T (4) T () + T () + 4a 4T (1) + 8a (da T () T (1) + a) 1a (da T (1) 3a) = 4c (da c = 3a) c 4 log 3 somit gilt für n = 4 : T (n) cn log(n 1). Somit gilt für n = 3: T (n) 3n log(n 1). entsprechend für n = 5 : T (n) cn log(n 1). 67 / 1 68 / 1

18 Der Fall n 6 : T (n) T l n m j n k + T + an l n m l n m j n k j n k c log 1 + c log 1 + an (per Induktion) c n + 1 = c n + 1 «n + 1 log 1 + c n n log 1 + an (Monotonie von log) n 1 log «+ c n «n log + an = 1 c(n + 1) log(n 1) + 1 n + 1 cn log(n ) c c n + an = 1 c(n + 1) log(n 1) + 1 n + 1 cn log(n ) c c n + an 1 c(n + 1) log(n 1) + 1 n + 1 cn log(n 1) c c n + an 1 cn log(n 1) + 1 c log(n 1) + 1 cn log(n 1) cn c + an = cn log(n 1) + c log(n 1) cn c + c n (da c = 3a) 3 cn log(n 1) c (n + 1 log(n 1)) + c n cn log(n 1) c (n + 1 log(n 1)) + c {z } n ( n) 69 / 1 70 / 1 cn log(n 1) c (n + 1 log(n 1)) + c {z } n ( n) cn log(n 1) c n + c n = cn log(n 1) Wir haben bisher: trivialer Ansatz: O(n 3 ) etwas weniger trivialer Ansatz: O(n ). Ansatz: O(n log n) Ist dies bestmöglich? 71 / 1 7 / 1

19 3. Versuch: sei lmax i Grenze i der Wert einer maximalen Teilsumme mit fester rechter wobei die leere Folge zugelassen ist sei bismax i der maximale Wert im Intervall [1,..., i] bismax lmax i es gilt: bismax lmax i lmax i+1 = j lmaxi + X (i + 1), falls lmax i + X (i + 1) > 0 0, falls lmax i + X (i + 1) 0 bismax i+1 = max{bismax i, lmax i+1 } 73 / 1 74 / 1 Scanline-Ansatz 3. Versuch: Scan Line Prinzip Idee: durchlaufe das Array von links nach rechts in Position i aktualisiere: bismax lmax msp3(x, n) lmax = 0 bismax = 0 for i=1 to n do a = X(i) Aktualisierung if (lmax + a > 0) lmax = lmax + a else lmax = 0 end if if (lmax > bismax) bismax = lmax end do return bismax 75 / 1 76 / 1

20 Skizze: Scanline vorher nachher a bismax lmax offensichtlich: T (n) = O(n) jeder MSP-Algorithmus benötigt wenigstens n Schritte der scanline-ansatz ist optimal (bis auf Konstanten) 77 / 1