Kapitel 2: Analyse der Laufzeit von Algorithmen Gliederung

Transkript

1 Gliederung 1. Motivation / Einordnung / Grundlagen 2. Analyse der Laufzeit von Algorithmen 3. Untere Schranken für algorithmische Probleme 4. Sortier- und Selektionsverfahren 5. Paradigmen des Algorithmenentwurfs 6. Ausgewählte Datenstrukturen 7. Algorithmische Geometrie 8. Umgang mit algorithmisch schwierigen Problemen Analyse rekursiver Algorithmen amortisierte Analyse 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

2 Einordnung u... es geht uns darum, einige Methoden kennenzulernen, die wir benutzen können, um die Laufzeit von Algorithmen sinnvoll abzuschätzen im Mittelpunkt stehen die Analyse von Algorithmen, die rekursiv definiert sind die Analyse von Algorithmen, bei denen Operationen eine Rolle spielen, deren Laufzeit / Kosten variabel sind, d.h. sich über die Zeit ändern 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

3 Analyse rekursiver Algorithmen u... bereits diskutierte Beispiele Divide-and-Conquer-Algorithmus für das Maximale-Teilsummen-Problem rekursiver Algorithmus zum Bestimmen des Maximums einer Zahlenfolge u... andere bekannte Beispiele Sortieren durch Auswählen Quick-Sort... für rekursive Lösungsalgorithmen ist typisch, dass sich die Komplexitätsfunktion des Algorithmus ebenfalls rekursiv beschreiben lässt 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

4 Analyse rekursiver Algorithmen u Beispiel: Maximum bestimmen rekursive Beschreibung des Algorithmus Eingabe: Zahlenfolge a[1],...,a[n] Berechnungsvorschrift: falls n = 1 ist, gib a[1] aus falls n > 1 ist, gehe wie folgt vor: bestimme zunächst das Maximum z des Anfangsstücks a[1],...,a[n-1] bestimme das Maximum von z und a[n] und gib diese Zahl aus rekursive Beschreibung der Komplexitätsfunktion T(n) für diesen Algorithmus (/* interessierende Operation: Vergleichsoperation */): T(1) = 0 T(n) = T(n-1) + 1 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

5 Analyse rekursiver Algorithmen u Beispiel: Sortieren durch Auswählen rekursive Beschreibung des Algorithmus Eingabe: Zahlenfolge a[1],...,a[n] Berechnungsvorschrift: falls n = 1 ist, gib a[1] aus falls n > 1 ist, gehe wie folgt vor: bestimme das i in der Zahlenfolge a[1],...,a[n], für das a[i] maximal ist vertausche die Elemente a[n] und a[i] sortiere die Zahlenfolge a[1],...,a[n-1] rekursive Beschreibung der Komplexitätsfunktion T(n) für diesen Algorithmus (/* interessierende Operationen: Vergleichsoperation und Austauschoperation */): T(1) = 0 T(n) = T(n-1) + n 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

6 Analyse rekursiver Algorithmen u Zwischenzusammenfassung es geht darum, Komplexitätsfunktionen abzuschätzen, die wie folgt beschrieben werden die Laufzeit für Eingaben der Größe n hängt sowohl von n als auch von der Laufzeit für Eingaben einer Größe kleiner als n ab u prominente Beispiele Basisfall: T(1) = c zugehörige Rekursionsgleichungen: T(n) = T(n-1) + c T(n) = 2T(n/2) + c*n T(n) = 3T(n/2) + c*n /1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

7 Analyse rekursiver Algorithmen u Zielstellung rekursiv beschriebene Komplexitätsfunktionen mit Hilfe von einfachen Funktionen abzuschätzen u typische Beispiele Basisfall: T(1) = c zugehörige Rekursionsgleichung: a) T(n) = T(n-1) + c b) T(n) = 2T(n/2) + c*n c) T(n) = 3T(n/2) + c*n 2 a) T(n) Θ(g(n)) mit g(n) = n b) T(n) Θ(g(n)) mit g(n) = n*log(n) c) T(n) Θ(g(n)) mit g(n) = n 2 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

8 Analyse rekursiver Algorithmen u Typische Herangehensweisen Einsetzen und Aufsummieren Raten und die Vermutung mit Hilfe eines induktiven Beweises überprüfen Anwendung des Master-Theorems... die letzte Methode wird für fast alle Abschätzungen, die im Rahmen der Vorlesung relevant sind, genügen 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

9 Einsetzen und Aufsummieren u Erstes Beispiel Basisfall: T(1) = c zugehörige Rekursionsgleichung: T(n) = T(n-1) + c T(n) = c + T(n-1) = c + c + T(n-2) =... = c + c c = c*n... also: T(n) Θ(g(n)) mit g(n) = n 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

10 Einsetzen und Aufsummieren u Zweites Beispiel Basisfall: T(1) = 1 zugehörige Rekursionsgleichung: T(n) = T(n-1) + n T(n) = n + T(n-1) = n + (n-1) + T(n-2) =... = n + (n-1) = n * (n+1) / 2... also: T(n) Θ(g(n)) mit g(n) = n 2 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

11 Einsetzen und Aufsummieren u Drittes Beispiel Basisfall: T(1) = 1 zugehörige Rekursionsgleichung: T(n) = T(n-1) + n 2 T(n) = n 2 + T(n-1) = n 2 + (n-1) 2 + T(n-2) =... = n 2 + (n-1) offenbar gilt: T(n) n*n 2 = n 3 offenbar gilt: T(n) (n/2)*(n/2) 2 = n 3 /8... also: T(n) Θ(g(n)) mit g(n) = n 3 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

12 Raten und die Vermutung mit Hilfe eines induktiven Beweises überprüfen u Beispiel Basisfall: T(1) = 0 zugehörige Rekursionsgleichung: T(n) = 2T(n/2) + n erste (/* falsche */) Vermutung: es gilt T(n) c*n für ein geeignet gewähltes c unter der Annahme, dass für alle n < n die Vermutung gilt, kann man diese Induktionsvoraussetzung nun wie folgt benutzen: T(n) 2*(c *n/2) + *n = c *n + *n = (c +1)*n... Unsinn, da unsere Konstante c um 1 größer werden müsste, wenn sich n verdoppelt (/* aber ein guter Ausgangspunkt für eine neue Vermutung */) 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

13 Raten und die Vermutung mit Hilfe eines induktiven Beweises überprüfen u Beispiel (cont.) Basisfall: T(1) = 0 zugehörige Rekursionsgleichung: T(n) = 2T(n/2) + n zweite (/* richtige */) Vermutung: es gilt T(n) c*n*log 2 (n) für ein geeignet gewähltes c 1 unter der Annahme, dass für alle n < n die Vermutung gilt, kann man diese Induktionsvoraussetzung wie folgt benutzen: T(n) 2*(c*n/2*log 2 (n/2)) + n = c*n*(log 2 (n/2)) + n = c*n*(log 2 (n) - log 2 (2)) + n = c*n*log 2 (n) - c*n + n c*n*log 2 (n) - c*n + c*n = c*n*log 2 (n)... unsere Vermutung ist richtig und wir erhalten damit: T(n) O(g(n)) mit g(n) = n*log 2 (n) 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

14 u Zielstellung wir wollen uns ein Hilfsmittel verschaffen, um alle Rekursionen vom folgenden Typ in den Griff zu bekommen es seien a, b und c irgendwelche Konstanten größer als 0 Basisfall: T(1) = c zugehörige Rekursionsgleichung: T(n) = a*t(n/b) + c*n k... solcherart Rekursionen findet man typischerweise bei Algorithmen, die nach dem Divide-and-Conquer-Ansatz konzipiert wurden... in vielen Fällen wird man statt des Gleichheitszeichens ein - Zeichen finden 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

15 u Erstes Beispiel Basisfall: T(1) = c zugehörige Rekursionsgleichung: T(n) = 2*T(n/2) + c sukzessives Einsetzen bspw. für n = 2 3 liefert folgenden Rekursionsbaum: c c c c c c c c c c c c c c c 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

16 u Zweites Beispiel (/* cont. /*) Aufsummieren über die einzelnen Ebenen liefert: Wurzel: c 1. Ebene: 2*c 2. Ebene: 4*c 3. Ebene: 8*c... insgesamt: 2*c*n 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

17 u Zweites Beispiel Basisfall: T(1) = c zugehörige Rekursionsgleichung: T(n) = 2*T(n/2) + c*n sukzessives Einsetzen bspw. für n = 2 3 liefert folgenden Rekursionsbaum: c*n c*(n/2) c*(n/2) c*(n/4) c*(n/4) c*(n/4) c*(n/4) c*(n/8) c*(n/8) c*(n/8) c*(n/8) c*(n/8) c*(n/8) c*(n/8) c*(n/8) 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

18 u Zweites Beispiel (/* cont. /*) Aufsummieren über die einzelnen Ebenen liefert: Wurzel: c*n 1. Ebene: 2*c*(n/2) = c*n 2. Ebene: 4*c*(n/4) = c*n 3. Ebene: 8*c*(n/8) = c*n... insgesamt: c*n*(log 2 (n) + 1) 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

19 u Drittes Beispiel Basisfall: T(1) = c zugehörige Rekursionsgleichung: T(n) = 2*T(n/2) + c*n 2 sukzessives Einsetzen bspw. für n = 2 3 liefert folgenden Rekursionsbaum: c*n 2 c*(n/2) 2 c*(n/2) 2 c*(n/4) 2 c*(n/4) 2 c*(n/4) 2 c*(n/4) 2 c*(n/8) 2 c*(n/8) 2 c*(n/8) 2 c*(n/8) 2 c*(n/8) 2 c*(n/8) 2 c*(n/8) 2 c*(n/8) 2 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

20 u Drittes Beispiel (/* cont. /*) Aufsummieren über die einzelnen Ebenen liefert: Wurzel: c*n 2 1. Ebene: 2*c*(n/2) 2 = (c*n 2 )/2 2. Ebene: 4*c*(n/4) 2 = (c*n 2 )/4 3. Ebene: 8*c*(n/8) = (c*n 2 )/8... insgesamt: 2*c*n 2 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

21 u... und jetzt allgemeiner es seien a, b und c irgendwelche Konstanten größer als 0 Basisfall: T(1) = c zugehörige Rekursionsgleichung: T(n) = a*t(n/b) + c*n k es sei o.b.d.a. n eine Potenz von b dann ergibt sich durch Analyse des Rekursionsbaums: T(n) = c*n k + a*c*(n/b) k + a 2 *c*(n/b 2 ) k a log b (n) *c*(n/b log b (n) ) k das Anwenden von Potenzgesetzen liefert: T(n) = c*n k + c*n k *(a/b k ) + c*n k *(a/b k ) c*n k *(a/b k ) log b (n) 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

22 u... und jetzt allgemeiner (/* cont. */) wir setzen r = a/b k und erhalten: T(n) = c*n k *r 0 + c*n k *r 1 + c*n k *r c*n k *r log b (n) offenbar kann nur einer der folgenden drei Fälle eintreten: Fall A: r = 1, d.h. a = b k Fall B: r < 1, d.h. a < b k Fall C: r > 1, d.h. a > b k... wir untersuchen jetzt diese drei Fälle separat 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

23 u zu Fall A (/* r = 1, d.h. a = b k */) offenbar erhalten wir: T(n) = c*n k *1 0 + c*n k *1 1 + c*n k* c*n k* 1 log b (n) also gilt: T(n) = c*n k *(log b (n)+1)... also erhalten wir: T(n) Θ(g(n)) mit g(n) = n k *log 2 (n) 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

24 u zu Fall B (/* r < 1, d.h. a < b k */) offenbar erhalten wir: T(n) = c*n k *[ r 0 + r 1 + r r log b (n) ] also gilt: T(n) c*n k T(n) c*n k *[r 0 + r 1 + r ] = c*n k *(1/1-r) (/* Grenzwert für geometrische Reihen einsetzen */)... also erhalten wir: T(n) Θ(g(n)) mit g(n) = n k 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

25 u zu Fall C (/* r >1, d.h. a > b k */) offenbar erhalten wir wieder: T(n) = c*n k *[ r 0 + *r 1 + r r log b (n) ] Ausklammern der größten Terms liefert: T(n) = c*n k *r log b (n) [ r 0 /r log b (n) + r 1 /r log b (n) + r 2 /r log b (n) r log b (n) /r log b (n) ] also gilt: T(n) = c*n k *r log b (n) [ (1/r) log b (n) + (1/r) log b (n)-1 + (1/r) log b (n) (1/r) 0 ] da 1/r < 1 ist, erhalten wir wie in Fall B: T(n) Θ(g(n)) mit g(n) = n k *r log b (n) 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

26 u zu Fall C (/* r >1, d.h. a > b k (/* cont. */) wir schauen uns den folgenden Term genauer an: g(n) = n k *r log b (n) wegen r = a/b k gilt: g(n) = n k *(a log b (n) /b k * log b (n) ) wegen b log b (n) = n gilt auch noch: g(n) = a log b (n) da per Definition sowohl a = b log b (a) als auch b log b (n) = n gilt, können wir schreiben: g(n) = n log b (a)... also erhalten wir: T(n) Θ(g(n)) mit g(n) = n log b (a) 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik

27 u Zusammenfassung (/* unser */) Es seien a, b und c Konstanten größer 0, so dass sich die Komplexitätsfunktion eines Algorithmus A wie folgt beschreiben lässt: Dann gilt: Basisfall: T(1) = c zugehörige Rekursionsgleichung: T(n) = a*t(n/b) + c*n k Wenn a < b k ist, so ist T(n) Θ(g(n)) mit g(n) = n k. Wenn a = b k ist, so ist T(n) Θ(g(n)) mit g(n) = n k *log(n). Wenn a > b k ist, so ist T(n) Θ(g(n)) mit g(n) = n log b (a). 2/1, Folie Prof. Steffen Lange - HDa/FbI - Algorithmik