VL-04: Rekursionsgleichungen

VL-04: Rekursionsgleichungen
(Datenstrukturen und Algorithmen, SS 2017)
Gerhard Woeginger
SS 2017, RWTH
DSAL/SS 2017
VL-04: Rekursionsgleichungen
1/37
Organisatorisches
• Vorlesung: Gerhard Woeginger (Zimmer 4024 im E1)
Sprechstunde: Mittwoch 11:15–12:00
• Übungen: Tim Hartmann, David Korzeniewski, Björn Tauer
Email: [email protected]
• Webseite: http://algo.rwth-aachen.de/Lehre/SS17/DSA.php
• Nächste Vorlesung:
Dienstag, Mai 2, 16:15–17:45 Uhr, Aula 1
DSAL/SS 2017
VL-04: Rekursionsgleichungen
2/37
Organisatorisches
Zulassungsvoraussetzungen für Klausur (ausser CES und Lehramt)
• 50% der Punkte in den Hausaufgaben
• einmal im Semester eine Hausaufgabe im Tutorium vorrechnen
Achtung:
Zulassungen aus dem SS16 sind nicht mehr gültig!
Bonusregel (auch für CES und Lehramt)
Mindestens 70% der Punkte in den Hausaufgaben
⇒ Klausurnote verbessert sich um eine Stufe (= 0.3)
Wir empfehlen allen Studenten, die Übungen zu erarbeiten
DSAL/SS 2017
VL-04: Rekursionsgleichungen
3/37
Anmerkungen (zur Vorlesung VL-03)
Suchen in einer sortierten Matrix
Eingabe: Eine sortierte n×n Matrix E; das gesuchte Element K.
Ausgabe: Ist K in E enthalten?
Ein typisches Problem
Eingabe: Ein Datensatz xyz, der eine gewisse Eigenschaft abcd erfüllt
Ausgabe: Ein Ergebnis αβγ
• Der Lösungsalgorithmus braucht in diesem Fall nur für Eingaben
mit dieser Eigenschaft abcd zu funktionieren
• Die Eigenschaft abcd muss nicht extra überprüft/verifiziert werden
• Dies gilt für die gesamte Vorlesung (+ Übungen + Klausur)
DSAL/SS 2017
VL-04: Rekursionsgleichungen
4/37
Rekursionsgleichungen
• Grundlagen
• Fibonacci-Zahlen
• Ermitteln von Rekursionsgleichungen
• Substitutionsmethode
• Rekursionsbäume
DSAL/SS 2017
VL-04: Rekursionsgleichungen
5/37
Rekursionsgleichungen
Rekursionsgleichung
Für rekursive Algorithmen wird die Laufzeit meistens durch so-genannte
Rekursionsgleichungen beschrieben:
Eine Rekursionsgleichung ist eine Gleichung (oder Ungleichung), die
eine Funktion durch ihre eigenen Funktionswerte für kleinere Eingaben
beschreibt.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
6/37
Rekursionsgleichungen
Rekursionsgleichung
Für rekursive Algorithmen wird die Laufzeit meistens durch so-genannte
Rekursionsgleichungen beschrieben:
Eine Rekursionsgleichung ist eine Gleichung (oder Ungleichung), die
eine Funktion durch ihre eigenen Funktionswerte für kleinere Eingaben
beschreibt.
Beispiele
T (n) = T (n−1) + 1
DSAL/SS 2017
Lineare Suche
VL-04: Rekursionsgleichungen
6/37
Rekursionsgleichungen
Rekursionsgleichung
Für rekursive Algorithmen wird die Laufzeit meistens durch so-genannte
Rekursionsgleichungen beschrieben:
Eine Rekursionsgleichung ist eine Gleichung (oder Ungleichung), die
eine Funktion durch ihre eigenen Funktionswerte für kleinere Eingaben
beschreibt.
Beispiele
T (n) = T (n−1) + 1
Lineare Suche
T (n) = T (d(n−1)/2e) + 1
DSAL/SS 2017
VL-04: Rekursionsgleichungen
Binäre Suche
6/37
Rekursionsgleichungen
Rekursionsgleichung
Für rekursive Algorithmen wird die Laufzeit meistens durch so-genannte
Rekursionsgleichungen beschrieben:
Eine Rekursionsgleichung ist eine Gleichung (oder Ungleichung), die
eine Funktion durch ihre eigenen Funktionswerte für kleinere Eingaben
beschreibt.
Beispiele
T (n) = T (n−1) + 1
Lineare Suche
T (n) = T (d(n−1)/2e) + 1
T (n) = T (n−1) + n − 1
DSAL/SS 2017
Binäre Suche
Bubblesort
VL-04: Rekursionsgleichungen
6/37
Rekursionsgleichungen
Rekursionsgleichung
Für rekursive Algorithmen wird die Laufzeit meistens durch so-genannte
Rekursionsgleichungen beschrieben:
Eine Rekursionsgleichung ist eine Gleichung (oder Ungleichung), die
eine Funktion durch ihre eigenen Funktionswerte für kleinere Eingaben
beschreibt.
Beispiele
T (n) = T (n−1) + 1
Lineare Suche
T (n) = T (d(n−1)/2e) + 1
DSAL/SS 2017
Binäre Suche
T (n) = T (n−1) + n − 1
Bubblesort
T (n) = 2·T (n/2) + n − 1
Mergesort
VL-04: Rekursionsgleichungen
6/37
Rekursionsgleichungen
Rekursionsgleichung
Für rekursive Algorithmen wird die Laufzeit meistens durch so-genannte
Rekursionsgleichungen beschrieben:
Eine Rekursionsgleichung ist eine Gleichung (oder Ungleichung), die
eine Funktion durch ihre eigenen Funktionswerte für kleinere Eingaben
beschreibt.
Beispiele
T (n) = T (n−1) + 1
Lineare Suche
T (n) = T (d(n−1)/2e) + 1
T (n) = T (n−1) + n − 1
Bubblesort
T (n) = 2·T (n/2) + n − 1
Mergesort
T (n) = 7·T (n/2) + c·n
DSAL/SS 2017
Binäre Suche
2
Strassen’s Matrixmultiplikation
VL-04: Rekursionsgleichungen
6/37
Rekursionen für Fibonacci-Zahlen
DSAL/SS 2017
VL-04: Rekursionsgleichungen
7/37
Fibonacci-Zahlen: Definition
Wachstum einer Kaninchenpopulation
Zu Beginn gibt es ein Paar geschlechtsreifer Kaninchen.
Jedes neugeborene Paar wird im zweiten Lebensmonat
geschlechtsreif.
Jedes geschlechtsreife Paar wirft pro Monat ein weiteres Paar.
Sie sterben nie und hören niemals auf.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
8/37
Fibonacci-Zahlen: Definition
Wachstum einer Kaninchenpopulation
Zu Beginn gibt es ein Paar geschlechtsreifer Kaninchen.
Jedes neugeborene Paar wird im zweiten Lebensmonat
geschlechtsreif.
Jedes geschlechtsreife Paar wirft pro Monat ein weiteres Paar.
Sie sterben nie und hören niemals auf.
Die Anzahl der Kaninchenpaare lässt sich wie folgt berechnen:
Fib(0) = 0
und Fib(1) = 1
für n ≥ 0.
Fib(n+2) = Fib(n+1) + Fib(n)
n
Fib(n)
DSAL/SS 2017
0
0
1
1
2
1
3
2
4
3
5
5
6
8
7
13
8
21
VL-04: Rekursionsgleichungen
9
34
...
...
8/37
Fibonacci-Zahlen: Naiver rekursiver Algorithmus (1)
Rekursiver Algorithmus
1
2
3
4
5
6
DSAL/SS 2017
int fibRec ( int n ) {
if ( n == 0 || n == 1) {
return n ;
}
return fibRec ( n - 1) + fibRec ( n - 2) ;
}
VL-04: Rekursionsgleichungen
9/37
Fibonacci-Zahlen: Naiver rekursiver Algorithmus (1)
Rekursiver Algorithmus
1
2
3
4
5
6
int fibRec ( int n ) {
if ( n == 0 || n == 1) {
return n ;
}
return fibRec ( n - 1) + fibRec ( n - 2) ;
}
Die zur Berechnung von fibRec(n) benötigte Anzahl arithmetischer
Operationen TfibRec (n) ist durch folgende Rekursionsgleichung gegeben:
TfibRec (0) = 0
TfibRec (1) = 0
TfibRec (n+2) = TfibRec (n+1) + TfibRec (n) + 3
für n ≥ 0.
Zur Ermittlung der Zeitkomplexität von fibRec löst man diese Gleichung.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
9/37
Fibonacci-Zahlen: Naiver rekursiver Algorithmus (2)
Problem
TfibRec (0) = 0
TfibRec (1) = 0
TfibRec (n + 2) = TfibRec (n + 1) + TfibRec (n) + 3
DSAL/SS 2017
VL-04: Rekursionsgleichungen
für n ≥ 0.
10/37
Fibonacci-Zahlen: Naiver rekursiver Algorithmus (2)
Problem
TfibRec (0) = 0
TfibRec (1) = 0
TfibRec (n + 2) = TfibRec (n + 1) + TfibRec (n) + 3
für n ≥ 0.
Lösung (mittels vollständiger Induktion)
TfibRec (n) = 3 · Fib(n + 1) − 3.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
10/37
Fibonacci-Zahlen: Naiver rekursiver Algorithmus (2)
Problem
TfibRec (0) = 0
TfibRec (1) = 0
TfibRec (n + 2) = TfibRec (n + 1) + TfibRec (n) + 3
für n ≥ 0.
Lösung (mittels vollständiger Induktion)
TfibRec (n) = 3 · Fib(n + 1) − 3.
Fakt
Fib(n) ∈ Θ(αn ) wobei α = 12 (1 +
√
5) ≈ 1.618.
Damit ergibt sich:
TfibRec (n) ∈ Θ(αn ).
DSAL/SS 2017
VL-04: Rekursionsgleichungen
10/37
Fibonacci-Zahlen: Iterativer Algorithmus (1)
Iterativer Algorithmus
1
2
3
4
5
6
7
8
DSAL/SS 2017
int fibIter ( int n ) {
int f [ n ];
f [0] = 0; f [1] = 1;
for ( int i = 2; i <= n ; i ++) {
f [ i ] = f [i -1] + f [i -2];
}
return f [ n ];
}
VL-04: Rekursionsgleichungen
11/37
Fibonacci-Zahlen: Iterativer Algorithmus (1)
Iterativer Algorithmus
1
2
3
4
5
6
7
8
int fibIter ( int n ) {
int f [ n ];
f [0] = 0; f [1] = 1;
for ( int i = 2; i <= n ; i ++) {
f [ i ] = f [i -1] + f [i -2];
}
return f [ n ];
}
Die benötigte Anzahl arithmetischer Operationen TfibIter (n) ist:
TfibIter (0) = 0
und TfibIter (1) = 0
TfibIter (n + 2) = 3 · (n + 1)
DSAL/SS 2017
für n ≥ 0.
VL-04: Rekursionsgleichungen
11/37
Fibonacci-Zahlen: Iterativer Algorithmus (1)
Iterativer Algorithmus
1
2
3
4
5
6
7
8
int fibIter ( int n ) {
int f [ n ];
f [0] = 0; f [1] = 1;
for ( int i = 2; i <= n ; i ++) {
f [ i ] = f [i -1] + f [i -2];
}
return f [ n ];
}
Die benötigte Anzahl arithmetischer Operationen TfibIter (n) ist:
TfibIter (0) = 0
und TfibIter (1) = 0
TfibIter (n + 2) = 3 · (n + 1)
für n ≥ 0.
Damit ergibt sich:
TfibIter (n) ∈ Θ(n).
DSAL/SS 2017
VL-04: Rekursionsgleichungen
11/37
Fibonacci-Zahlen: Iterativer Algorithmus (2)
Caveat:
Der fibIter Algorithmus hat Speicherkomplexität Θ(n).
DSAL/SS 2017
VL-04: Rekursionsgleichungen
12/37
Fibonacci-Zahlen: Iterativer Algorithmus (2)
Caveat:
Der fibIter Algorithmus hat Speicherkomplexität Θ(n).
• Beobachtung: Jeder Durchlauf benutzt nur Werte f[i-1] und f[i-2].
• Zwei Variablen reichen also aus, um diese Werte zu speichern.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
12/37
Fibonacci-Zahlen: Iterativer Algorithmus (2)
Caveat:
Der fibIter Algorithmus hat Speicherkomplexität Θ(n).
• Beobachtung: Jeder Durchlauf benutzt nur Werte f[i-1] und f[i-2].
• Zwei Variablen reichen also aus, um diese Werte zu speichern.
Iterativer Algorithmus
1
2
3
4
5
6
7
8
9
int fibIter2 ( int n ) {
int a = 0; int b = 1;
for ( int i = 2; i <= n ; i ++) {
c = a + b;
a = b;
b = c;
}
return b ;
}
fibIter2
DSAL/SS 2017
hat Speicherkomplexität Θ(1) und TfibIter 2 (n) ∈ Θ(n).
VL-04: Rekursionsgleichungen
12/37
Fibonacci-Zahlen: Matrixpotenz-Algorithmus (1)
Matrixdarstellung der Fibonacci-Zahlen
Es gilt für n > 0:
Fib(n+2)
1
=
Fib(n+1)
1
DSAL/SS 2017
1
0
Fib(n+1)
·
Fib(n)
VL-04: Rekursionsgleichungen
13/37
Fibonacci-Zahlen: Matrixpotenz-Algorithmus (1)
Matrixdarstellung der Fibonacci-Zahlen
Es gilt für n > 0:
Fib(n+2)
1
=
Fib(n+1)
1
1
0
Fib(n+1)
·
Fib(n)
Damit lässt sich Fib(n+2) durch Matrixpotenzierung berechnen:
2 Fib(n+2)
1 1
Fib(n)
=
·
Fib(n+1)
1 0
Fib(n−1)
n 1 1
Fib(2)
= ... =
·
1 0
Fib(1)
Wie können wir Matrixpotenzen effizient berechnen?
DSAL/SS 2017
VL-04: Rekursionsgleichungen
13/37
Fibonacci-Zahlen: Matrixpotenz-Algorithmus (2)
1
2
3
4
5
6
int fibMat ( int n ) {
if ( n == 0 || n == 1) { return n ; }
int Fib2 [2 ,2] = { {0 , 1} , {1 , 1} };
int Res [2 ,2] = iterSq ( Fib2 , n - 1) ; // Matrixpotenz
return Res [1 ,1]; // das Element Res [1 ,1]
}
Wie berechnet man a100 ?
DSAL/SS 2017
VL-04: Rekursionsgleichungen
14/37
Fibonacci-Zahlen: Matrixpotenz-Algorithmus (2)
1
2
3
4
5
6
int fibMat ( int n ) {
if ( n == 0 || n == 1) { return n ; }
int Fib2 [2 ,2] = { {0 , 1} , {1 , 1} };
int Res [2 ,2] = iterSq ( Fib2 , n - 1) ; // Matrixpotenz
return Res [1 ,1]; // das Element Res [1 ,1]
}
Wie berechnet man a100 ?
• 100 = 64 + 32 + 4
• Berechne a2 , a4 , a8 , a16 , a32 , a64
• Multipliziere a64 · a32 · a4 (= a100 )
DSAL/SS 2017
VL-04: Rekursionsgleichungen
14/37
Fibonacci-Zahlen: Matrixpotenz-Algorithmus (3)
Nebenfrage:
Wie berechnet man an möglichst schnell?
DSAL/SS 2017
VL-04: Rekursionsgleichungen
15/37
Fibonacci-Zahlen: Matrixpotenz-Algorithmus (3)
Nebenfrage:
Wie berechnet man an möglichst schnell?
• Bestimme die Binärdarstellung von n
• Berechne a2 , a4 , a8 , a16 , etc durch wiederholtes Quadrieren
• Multipliziere die Potenzen von a,
die den Einsen in der Binärdarstellung von n entsprechen
DSAL/SS 2017
VL-04: Rekursionsgleichungen
15/37
Fibonacci-Zahlen: Matrixpotenz-Algorithmus (3)
Nebenfrage:
Wie berechnet man an möglichst schnell?
• Bestimme die Binärdarstellung von n
• Berechne a2 , a4 , a8 , a16 , etc durch wiederholtes Quadrieren
• Multipliziere die Potenzen von a,
die den Einsen in der Binärdarstellung von n entsprechen
Nebenantwort:
Die Potenz an kann mit O(log n) Multiplikationen berechnet werden.
Anmerkung:
a15 = a3 × ((a3 )2 )2 geht mit fünf Multiplikationen
DSAL/SS 2017
VL-04: Rekursionsgleichungen
15/37
Fibonacci-Zahlen: Matrixpotenz-Algorithmus (4)
1
2
3
4
5
6
7
8
9
10
11
12
int [2 ,2] iterSq ( int A [2 ,2] , int n ) { // n > 0
int Res [2 ,2];
if ( n == 1) {
return A ;
} else if ( n % 2) { // n ungerade
Res = matrixSquare (A , (n -1) /2) ;
return Res * Res * A ;
} else { // n gerade
Res = matrixSquare (A , n /2) ;
return Res * Res ;
}
}
Folgerung
Algorithmus fibMat hat Zeitkomplexität Θ(log n).
DSAL/SS 2017
VL-04: Rekursionsgleichungen
16/37
Fibonacci-Zahlen: Praktische Konsequenzen
Beispiel
Grösste lösbare Eingabelänge n für angenommene 1 µs pro Operation:
Verfügbare Zeit
1 ms
1s
1m
1h
Rekursiv
Iterativ
Matrix
14
500
1012
28
5 · 105
1012 000
7
37
3 · 10
10700 000
6
45
1,8 · 109
1010
Lösbare Eingabelänge
Vereinfachende Annahmen:
Wir berücksichtigen nur arithmetische Operationen
Die Laufzeit der arithmetischen Operationen ist fix
(also: nicht von ihren jeweiligen Argumenten abhängig)
DSAL/SS 2017
VL-04: Rekursionsgleichungen
17/37
Ermitteln von Rekursionsgleichungen
DSAL/SS 2017
VL-04: Rekursionsgleichungen
18/37
Rekursionsgleichungen vom Programmcode ableiten
Rekursionsgleichung im Worst-Case
Zur Ermittlung der Worst-Case Laufzeit T (n) zerlegen wir das
Programm:
Die Kosten aufeinanderfolgender Blöcke werden addiert.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
19/37
Rekursionsgleichungen vom Programmcode ableiten
Rekursionsgleichung im Worst-Case
Zur Ermittlung der Worst-Case Laufzeit T (n) zerlegen wir das
Programm:
Die Kosten aufeinanderfolgender Blöcke werden addiert.
Von alternativen Blöcken wird das Maximum genommen.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
19/37
Rekursionsgleichungen vom Programmcode ableiten
Rekursionsgleichung im Worst-Case
Zur Ermittlung der Worst-Case Laufzeit T (n) zerlegen wir das
Programm:
Die Kosten aufeinanderfolgender Blöcke werden addiert.
Von alternativen Blöcken wird das Maximum genommen.
Beim Aufruf von Unterprogrammen (etwa sub1()) wird Tsub1 (f (n))
genommen, wobei f (n) die Länge der Parameter beim
Funktionsaufruf — abhängig von der Eingabelänge n des
Programms — ist.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
19/37
Rekursionsgleichungen vom Programmcode ableiten
Rekursionsgleichung im Worst-Case
Zur Ermittlung der Worst-Case Laufzeit T (n) zerlegen wir das
Programm:
Die Kosten aufeinanderfolgender Blöcke werden addiert.
Von alternativen Blöcken wird das Maximum genommen.
Beim Aufruf von Unterprogrammen (etwa sub1()) wird Tsub1 (f (n))
genommen, wobei f (n) die Länge der Parameter beim
Funktionsaufruf — abhängig von der Eingabelänge n des
Programms — ist.
Rekursive Aufrufe werden mit T (g(n)) veranschlagt; g(n) gibt die
von n abgeleitete Länge der Aufrufparameter an.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
19/37
Einige Vereinfachungen
Wenn wir Rekursionsgleichungen aufstellen und lösen,
vernachlässigen wir häufig das Runden auf ganze Zahlen, z. B.:
T (n) = T (bn/2c) + T (dn/2e) + 3
DSAL/SS 2017
wird T (n) = 2T (n/2) + 3.
VL-04: Rekursionsgleichungen
20/37
Einige Vereinfachungen
Wenn wir Rekursionsgleichungen aufstellen und lösen,
vernachlässigen wir häufig das Runden auf ganze Zahlen, z. B.:
T (n) = T (bn/2c) + T (dn/2e) + 3
wird T (n) = 2T (n/2) + 3.
Manchmal wird angenommen, dass T (n) für kleine n konstant ist
anstatt genau festzustellen was T (0) und T (1) ist. Also z. B.:
T (0) = c und T (1) = c 0
DSAL/SS 2017
statt
T (0) = 4 und T (1) = 7.
VL-04: Rekursionsgleichungen
20/37
Einige Vereinfachungen
Wenn wir Rekursionsgleichungen aufstellen und lösen,
vernachlässigen wir häufig das Runden auf ganze Zahlen, z. B.:
T (n) = T (bn/2c) + T (dn/2e) + 3
wird T (n) = 2T (n/2) + 3.
Manchmal wird angenommen, dass T (n) für kleine n konstant ist
anstatt genau festzustellen was T (0) und T (1) ist. Also z. B.:
T (0) = c und T (1) = c 0
statt
T (0) = 4 und T (1) = 7.
Wir nehmen an, dass die Funktionen nur ganzzahlige Argumente
haben, z. B.:
√
√
T (n) = T ( n) + n bedeutet T (n) = T (b nc) + n.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
20/37
Einige Vereinfachungen
Wenn wir Rekursionsgleichungen aufstellen und lösen,
vernachlässigen wir häufig das Runden auf ganze Zahlen, z. B.:
T (n) = T (bn/2c) + T (dn/2e) + 3
wird T (n) = 2T (n/2) + 3.
Manchmal wird angenommen, dass T (n) für kleine n konstant ist
anstatt genau festzustellen was T (0) und T (1) ist. Also z. B.:
T (0) = c und T (1) = c 0
statt
T (0) = 4 und T (1) = 7.
Wir nehmen an, dass die Funktionen nur ganzzahlige Argumente
haben, z. B.:
√
√
T (n) = T ( n) + n bedeutet T (n) = T (b nc) + n.
Rechtfertigung: Lösung wird typischerweise nur um konstanten
Faktor verändert, und Wachstumgrad bleibt unverändert.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
20/37
Lösung von Rekursionsgleichungen
DSAL/SS 2017
VL-04: Rekursionsgleichungen
21/37
Einfache Fälle
Für einfache Fälle gibt es geschlossene Lösungen, wie zum Beispiel:
Einfacher Fall
T (0) = k
T (n+1) = c·T (n)
für n ≥ 0
hat die eindeutige Lösung T (n) = c n ·k.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
22/37
Einfache Fälle
Für einfache Fälle gibt es geschlossene Lösungen, wie zum Beispiel:
Einfacher Fall
T (0) = k
T (n+1) = c·T (n)
für n ≥ 0
hat die eindeutige Lösung T (n) = c n ·k.
Noch ein einfacher Fall
T (0) = k
T (n+1) = T (n) + f (n)
für n ≥ 0
hat die eindeutige Lösung T (n) = T (0) +
n
X
f (i).
i=1
Bei der Zeitkomplexitätsanalyse treten solche Fälle jedoch selten auf.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
22/37
Der allgemeine Fall
Im allgemeinen Fall (der in dieser Vorlesung häufig auftritt) gibt es keine
geschlossene Lösung.
Allgemeines Format der Rekursionsgleichung
Der typische Fall sieht folgendermassen aus:
n
+ f (n)
T (n) = b · T
c
wobei b > 0, c > 1 gilt und f (n) eine gegebene Funktion ist.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
23/37
Der allgemeine Fall
Im allgemeinen Fall (der in dieser Vorlesung häufig auftritt) gibt es keine
geschlossene Lösung.
Allgemeines Format der Rekursionsgleichung
Der typische Fall sieht folgendermassen aus:
n
+ f (n)
T (n) = b · T
c
wobei b > 0, c > 1 gilt und f (n) eine gegebene Funktion ist.
Intuition:
Das zu analysierende Problem teilt sich jeweils in b Teilprobleme auf.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
23/37
Der allgemeine Fall
Im allgemeinen Fall (der in dieser Vorlesung häufig auftritt) gibt es keine
geschlossene Lösung.
Allgemeines Format der Rekursionsgleichung
Der typische Fall sieht folgendermassen aus:
n
+ f (n)
T (n) = b · T
c
wobei b > 0, c > 1 gilt und f (n) eine gegebene Funktion ist.
Intuition:
Das zu analysierende Problem teilt sich jeweils in b Teilprobleme auf.
Jedes dieser Teilprobleme hat die Grösse nc .
DSAL/SS 2017
VL-04: Rekursionsgleichungen
23/37
Der allgemeine Fall
Im allgemeinen Fall (der in dieser Vorlesung häufig auftritt) gibt es keine
geschlossene Lösung.
Allgemeines Format der Rekursionsgleichung
Der typische Fall sieht folgendermassen aus:
n
+ f (n)
T (n) = b · T
c
wobei b > 0, c > 1 gilt und f (n) eine gegebene Funktion ist.
Intuition:
Das zu analysierende Problem teilt sich jeweils in b Teilprobleme auf.
Jedes dieser Teilprobleme hat die Grösse nc .
Die Kosten für das Aufteilen eines Problems und für das
anschliessende Kombinieren der Teillösungen betragen f (n).
DSAL/SS 2017
VL-04: Rekursionsgleichungen
23/37
Die Substitutionsmethode
Substitutionsmethode
Die Substitutionsmethode besteht aus zwei Schritten:
1
Rate die Form der Lösung, zum Beispiel durch
DSAL/SS 2017
VL-04: Rekursionsgleichungen
24/37
Die Substitutionsmethode
Substitutionsmethode
Die Substitutionsmethode besteht aus zwei Schritten:
1
Rate die Form der Lösung, zum Beispiel durch
Scharfes Hinsehen, kurze Eingaben ausprobieren und einsetzen
DSAL/SS 2017
VL-04: Rekursionsgleichungen
24/37
Die Substitutionsmethode
Substitutionsmethode
Die Substitutionsmethode besteht aus zwei Schritten:
1
Rate die Form der Lösung, zum Beispiel durch
Scharfes Hinsehen, kurze Eingaben ausprobieren und einsetzen
Betrachtung des Rekursionsbaums
DSAL/SS 2017
VL-04: Rekursionsgleichungen
24/37
Die Substitutionsmethode
Substitutionsmethode
Die Substitutionsmethode besteht aus zwei Schritten:
1
Rate die Form der Lösung, zum Beispiel durch
Scharfes Hinsehen, kurze Eingaben ausprobieren und einsetzen
Betrachtung des Rekursionsbaums
2
DSAL/SS 2017
Verwende Vollständige Induktion, um die Konstanten zu finden und
um zu zeigen, dass die Lösung wirklich funktioniert.
VL-04: Rekursionsgleichungen
24/37
Die Substitutionsmethode
Substitutionsmethode
Die Substitutionsmethode besteht aus zwei Schritten:
1
Rate die Form der Lösung, zum Beispiel durch
Scharfes Hinsehen, kurze Eingaben ausprobieren und einsetzen
Betrachtung des Rekursionsbaums
2
Verwende Vollständige Induktion, um die Konstanten zu finden und
um zu zeigen, dass die Lösung wirklich funktioniert.
Einige Hinweise
Diese Methode ist sehr leistungsfähig,
kann aber nur in Fällen angewendet werden, in denen es relativ
einfach ist, die Form der Lösung zu erraten.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
24/37
Die Substitutionsmethode: Beispiel (1)
Beispiel
Betrachte folgende Rekursionsgleichung:
T (1) = 1
T (n) = 2 · T (n/2) + n
DSAL/SS 2017
für n > 1.
VL-04: Rekursionsgleichungen
25/37
Die Substitutionsmethode: Beispiel (1)
Beispiel
Betrachte folgende Rekursionsgleichung:
T (1) = 1
T (n) = 2 · T (n/2) + n
für n > 1.
Wir vermuten als Lösung T (n) ∈ O(n · log(n)).
DSAL/SS 2017
VL-04: Rekursionsgleichungen
25/37
Die Substitutionsmethode: Beispiel (1)
Beispiel
Betrachte folgende Rekursionsgleichung:
T (1) = 1
T (n) = 2 · T (n/2) + n
für n > 1.
Wir vermuten als Lösung T (n) ∈ O(n · log(n)).
Dazu müssen wir T (n) ≤ c·n· log(n) zeigen, für ein geeignet
gewähltes reelles c > 0.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
25/37
Die Substitutionsmethode: Beispiel (1)
Beispiel
Betrachte folgende Rekursionsgleichung:
T (1) = 1
T (n) = 2 · T (n/2) + n
für n > 1.
Wir vermuten als Lösung T (n) ∈ O(n · log(n)).
Dazu müssen wir T (n) ≤ c·n· log(n) zeigen, für ein geeignet
gewähltes reelles c > 0.
Wir suchen ein geeignetes n0 , sodass T (n) ≤ c·n· log(n) für n ≥ n0
gilt.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
25/37
Die Substitutionsmethode: Beispiel (1)
Beispiel
Betrachte folgende Rekursionsgleichung:
T (1) = 1
T (n) = 2 · T (n/2) + n
für n > 1.
Wir vermuten als Lösung T (n) ∈ O(n · log(n)).
Dazu müssen wir T (n) ≤ c·n· log(n) zeigen, für ein geeignet
gewähltes reelles c > 0.
Wir suchen ein geeignetes n0 , sodass T (n) ≤ c·n· log(n) für n ≥ n0
gilt.
Wir stellen fest, dass T (1) = 1 ≤ c·1· log(1) = 0 verletzt ist.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
25/37
Die Substitutionsmethode: Beispiel (1)
Beispiel
Betrachte folgende Rekursionsgleichung:
T (1) = 1
T (n) = 2 · T (n/2) + n
für n > 1.
Wir vermuten als Lösung T (n) ∈ O(n · log(n)).
Dazu müssen wir T (n) ≤ c·n· log(n) zeigen, für ein geeignet
gewähltes reelles c > 0.
Wir suchen ein geeignetes n0 , sodass T (n) ≤ c·n· log(n) für n ≥ n0
gilt.
Wir stellen fest, dass T (1) = 1 ≤ c·1· log(1) = 0 verletzt ist.
Es gilt: T (2) = 4 ≤ c·2 log(2) und T (3) = 5 ≤ c·3 log(3) für c ≥ 2
DSAL/SS 2017
VL-04: Rekursionsgleichungen
25/37
Die Substitutionsmethode: Beispiel (1)
Beispiel
Betrachte folgende Rekursionsgleichung:
T (1) = 1
T (n) = 2 · T (n/2) + n
für n > 1.
Wir vermuten als Lösung T (n) ∈ O(n · log(n)).
Dazu müssen wir T (n) ≤ c·n· log(n) zeigen, für ein geeignet
gewähltes reelles c > 0.
Wir suchen ein geeignetes n0 , sodass T (n) ≤ c·n· log(n) für n ≥ n0
gilt.
Wir stellen fest, dass T (1) = 1 ≤ c·1· log(1) = 0 verletzt ist.
Es gilt: T (2) = 4 ≤ c·2 log(2) und T (3) = 5 ≤ c·3 log(3) für c ≥ 2
Wir überprüfen dies dann durch Substitution und Induktion (siehe
Rechnung auf der nächsten Folie)
DSAL/SS 2017
VL-04: Rekursionsgleichungen
25/37
Die Substitutionsmethode: Beispiel (1)
Beispiel
Betrachte folgende Rekursionsgleichung:
T (1) = 1
T (n) = 2 · T (n/2) + n
für n > 1.
Wir vermuten als Lösung T (n) ∈ O(n · log(n)).
Dazu müssen wir T (n) ≤ c·n· log(n) zeigen, für ein geeignet
gewähltes reelles c > 0.
Wir suchen ein geeignetes n0 , sodass T (n) ≤ c·n· log(n) für n ≥ n0
gilt.
Wir stellen fest, dass T (1) = 1 ≤ c·1· log(1) = 0 verletzt ist.
Es gilt: T (2) = 4 ≤ c·2 log(2) und T (3) = 5 ≤ c·3 log(3) für c ≥ 2
Wir überprüfen dies dann durch Substitution und Induktion (siehe
Rechnung auf der nächsten Folie)
Damit gilt für jedes c ≥ 2 und n ≥ n0 > 1, dass T (n) ≤ c·n· log(n).
DSAL/SS 2017
VL-04: Rekursionsgleichungen
25/37
Die Substitutionsmethode: Beispiel (2)
Unser Ziel:
Zeige T (n) = 2 · T (n/2) + n für n > 1, und T (1) = 1
T (n)
DSAL/SS 2017
=
2 · T (n/2) + n
//Induktionshypothese
VL-04: Rekursionsgleichungen
26/37
Die Substitutionsmethode: Beispiel (2)
Unser Ziel:
Zeige T (n) = 2 · T (n/2) + n für n > 1, und T (1) = 1
T (n)
DSAL/SS 2017
=
2 · T (n/2) + n
≤
2 (c·n/2· log(n/2)) + n
//Induktionshypothese
VL-04: Rekursionsgleichungen
26/37
Die Substitutionsmethode: Beispiel (2)
Unser Ziel:
Zeige T (n) = 2 · T (n/2) + n für n > 1, und T (1) = 1
T (n)
DSAL/SS 2017
=
2 · T (n/2) + n
≤
2 (c·n/2· log(n/2)) + n
=
c·n· log(n/2) + n
//Induktionshypothese
//log2 (a/b) = log2 a − log2 b
VL-04: Rekursionsgleichungen
26/37
Die Substitutionsmethode: Beispiel (2)
Unser Ziel:
Zeige T (n) = 2 · T (n/2) + n für n > 1, und T (1) = 1
T (n)
DSAL/SS 2017
=
2 · T (n/2) + n
≤
2 (c·n/2· log(n/2)) + n
=
c·n· log(n/2) + n
=
c·n· log(n) − c·n· log(2) + n
//Induktionshypothese
//log2 (a/b) = log2 a − log2 b
VL-04: Rekursionsgleichungen
26/37
Die Substitutionsmethode: Beispiel (2)
Unser Ziel:
Zeige T (n) = 2 · T (n/2) + n für n > 1, und T (1) = 1
T (n)
DSAL/SS 2017
=
2 · T (n/2) + n
≤
2 (c·n/2· log(n/2)) + n
=
c·n· log(n/2) + n
=
c·n· log(n) − c·n· log(2) + n
=
c·n· log(n) − (c − 1)·n
//Induktionshypothese
//log2 (a/b) = log2 a − log2 b
//mit c ≥ 1 erhalten wir
VL-04: Rekursionsgleichungen
26/37
Die Substitutionsmethode: Beispiel (2)
Unser Ziel:
Zeige T (n) = 2 · T (n/2) + n für n > 1, und T (1) = 1
T (n)
DSAL/SS 2017
=
2 · T (n/2) + n
≤
2 (c·n/2· log(n/2)) + n
=
c·n· log(n/2) + n
=
c·n· log(n) − c·n· log(2) + n
=
c·n· log(n) − (c − 1)·n
≤
c·n· log(n)
//Induktionshypothese
//log2 (a/b) = log2 a − log2 b
//mit c ≥ 1 erhalten wir
//q.e.d.
VL-04: Rekursionsgleichungen
26/37
Die Substitutionsmethode: Feinheiten
Einige wichtige Hinweise
1
DSAL/SS 2017
Unter Umständen kann die asymptotische Schranke zwar korrekt
erraten, dann aber nicht mit vollständiger Induktion bewiesen
werden.
VL-04: Rekursionsgleichungen
27/37
Die Substitutionsmethode: Feinheiten
Einige wichtige Hinweise
1
DSAL/SS 2017
Unter Umständen kann die asymptotische Schranke zwar korrekt
erraten, dann aber nicht mit vollständiger Induktion bewiesen
werden.
Das Problem ist dann für gewöhnlich, dass die Induktionsannahme
nicht stark genug ist.
VL-04: Rekursionsgleichungen
27/37
Die Substitutionsmethode: Feinheiten
Einige wichtige Hinweise
1
Unter Umständen kann die asymptotische Schranke zwar korrekt
erraten, dann aber nicht mit vollständiger Induktion bewiesen
werden.
Das Problem ist dann für gewöhnlich, dass die Induktionsannahme
nicht stark genug ist.
2
Manchmal hilft eine Variablentransformation, um zu einer Lösung zu
gelangen:
√ T (n) = 2·T
n + log(n)
Der Bequemlichkeit halber kümmern wir uns hier nicht um die
Rundung von Werten.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
27/37
Die Substitutionsmethode: Variablentransformation
Beispiel
T (n) = 2·T
T (n)
DSAL/SS 2017
√ n + log(n) für n > 0
= 2·T
√ n + log n //Variablentransformation m = log n
VL-04: Rekursionsgleichungen
28/37
Die Substitutionsmethode: Variablentransformation
Beispiel
T (n) = 2·T
√ n + log(n) für n > 0
√ n + log n //Variablentransformation m = log n
T (2m ) = 2·T 2m/2 + m //Umbenennung T (2m ) = S(m)
T (n)
DSAL/SS 2017
= 2·T
VL-04: Rekursionsgleichungen
28/37
Die Substitutionsmethode: Variablentransformation
Beispiel
T (n) = 2·T
√ n + log(n) für n > 0
√ n + log n //Variablentransformation m = log n
T (2m ) = 2·T 2m/2 + m //Umbenennung T (2m ) = S(m)
T (n)
= 2·T
S(m) = 2·S(m/2) + m
DSAL/SS 2017
//Lösung unseres letzten Beispiels
VL-04: Rekursionsgleichungen
28/37
Die Substitutionsmethode: Variablentransformation
Beispiel
T (n) = 2·T
√ n + log(n) für n > 0
√ n + log n //Variablentransformation m = log n
T (2m ) = 2·T 2m/2 + m //Umbenennung T (2m ) = S(m)
T (n)
= 2·T
S(m) = 2·S(m/2) + m
//Lösung unseres letzten Beispiels
S(m) ≤ c·m· log(m)
DSAL/SS 2017
VL-04: Rekursionsgleichungen
28/37
Die Substitutionsmethode: Variablentransformation
Beispiel
T (n) = 2·T
√ n + log(n) für n > 0
√ n + log n //Variablentransformation m = log n
T (2m ) = 2·T 2m/2 + m //Umbenennung T (2m ) = S(m)
T (n)
= 2·T
S(m) = 2·S(m/2) + m
//Lösung unseres letzten Beispiels
S(m) ≤ c·m· log(m)
S(m)
DSAL/SS 2017
∈
O(m· log(m))
//m = log n
VL-04: Rekursionsgleichungen
28/37
Die Substitutionsmethode: Variablentransformation
Beispiel
T (n) = 2·T
√ n + log(n) für n > 0
√ n + log n //Variablentransformation m = log n
T (2m ) = 2·T 2m/2 + m //Umbenennung T (2m ) = S(m)
T (n)
= 2·T
S(m) = 2·S(m/2) + m
//Lösung unseres letzten Beispiels
S(m) ≤ c·m· log(m)
DSAL/SS 2017
S(m)
∈
O(m· log(m))
T (n)
∈
O(log n · log log n)
//m = log n
VL-04: Rekursionsgleichungen
28/37
Die Substitutionsmethode
Substitutionsmethode
Die Substitutionsmethode besteht aus zwei Schritten:
1
Rate die Form der Lösung, zum Beispiel durch
Scharfes Hinsehen, kurze Eingaben ausprobieren und einsetzen
Betrachtung des Rekursionsbaums
2
DSAL/SS 2017
Verwende Vollständige Induktion, um die Konstanten zu finden und
um zu zeigen, dass die Lösung wirklich funktioniert.
VL-04: Rekursionsgleichungen
29/37
Die Substitutionsmethode
Substitutionsmethode
Die Substitutionsmethode besteht aus zwei Schritten:
1
Rate die Form der Lösung, zum Beispiel durch
Scharfes Hinsehen, kurze Eingaben ausprobieren und einsetzen
Betrachtung des Rekursionsbaums
2
Verwende Vollständige Induktion, um die Konstanten zu finden und
um zu zeigen, dass die Lösung wirklich funktioniert.
Wir betrachten nun detaillierter,
auf welche Art und Weise man die Form der Lösung erraten kann.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
29/37
Raten der Lösung durch Iteration (1)
Grundidee
Wiederholtes Einsetzen der Rekursionsgleichung in sich selbst,
bis dass man ein Muster erkennt.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
30/37
Raten der Lösung durch Iteration (1)
Grundidee
Wiederholtes Einsetzen der Rekursionsgleichung in sich selbst,
bis dass man ein Muster erkennt.
Beispiel
T (n)
DSAL/SS 2017
=
3 · T (n/4) + n
//Einsetzen
VL-04: Rekursionsgleichungen
30/37
Raten der Lösung durch Iteration (1)
Grundidee
Wiederholtes Einsetzen der Rekursionsgleichung in sich selbst,
bis dass man ein Muster erkennt.
Beispiel
T (n)
DSAL/SS 2017
=
3 · T (n/4) + n
=
3 · (3 · T (n/16) + n/4)) + n
//Einsetzen
VL-04: Rekursionsgleichungen
//Nochmal einsetzen
30/37
Raten der Lösung durch Iteration (1)
Grundidee
Wiederholtes Einsetzen der Rekursionsgleichung in sich selbst,
bis dass man ein Muster erkennt.
Beispiel
T (n)
DSAL/SS 2017
=
3 · T (n/4) + n
=
3 · (3 · T (n/16) + n/4)) + n
=
9 · (3 · T (n/64) + n/16)) + 3 · n/4 + n
//Einsetzen
VL-04: Rekursionsgleichungen
//Nochmal einsetzen
//Vereinfachen
30/37
Raten der Lösung durch Iteration (1)
Grundidee
Wiederholtes Einsetzen der Rekursionsgleichung in sich selbst,
bis dass man ein Muster erkennt.
Beispiel
T (n)
=
3 · T (n/4) + n
=
3 · (3 · T (n/16) + n/4)) + n
=
9 · (3 · T (n/64) + n/16)) + 3 · n/4 + n
//Vereinfachen
2
1
0
3
3
3
27 · T (n/64) +
·n+
·n+
·n
4
4
4
=
DSAL/SS 2017
//Einsetzen
VL-04: Rekursionsgleichungen
//Nochmal einsetzen
30/37
Raten der Lösung durch Iteration (2)
Beispiel
T (n)
DSAL/SS 2017
=
3 · T (n/4) + n
=
1
0
2
3
3
3
·n+
·n+
·n
27 · T (n/64) +
4
4
4
VL-04: Rekursionsgleichungen
31/37
Raten der Lösung durch Iteration (2)
Beispiel
T (n)
=
3 · T (n/4) + n
=
1
0
2
3
3
3
·n+
·n+
·n
27 · T (n/64) +
4
4
4
Wir nehmen T (1) = c an und erhalten:
log4 n
T (n) =
DSAL/SS 2017
X 3 i
· n + c · nlog4 (3)
4
i=0
VL-04: Rekursionsgleichungen
31/37
Raten der Lösung durch Iteration (2)
Beispiel
T (n)
=
3 · T (n/4) + n
=
1
0
2
3
3
3
·n+
·n+
·n
27 · T (n/64) +
4
4
4
Wir nehmen T (1) = c an und erhalten:
log4 n
T (n) =
X 3 i
· n + c · nlog4 (3)
4
i=0
Diese Aussage kann nun mit der Substitutionsmethode bewiesen werden.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
31/37
Raten der Lösung durch Iteration (2)
Beispiel
T (n)
=
3 · T (n/4) + n
=
1
0
2
3
3
3
·n+
·n+
·n
27 · T (n/64) +
4
4
4
Wir nehmen T (1) = c an und erhalten:
log4 n
T (n) =
X 3 i
· n + c · nlog4 (3)
4
i=0
Diese Aussage kann nun mit der Substitutionsmethode bewiesen werden.
Mit Rekursionsbäumen sieht man das aber viel besser!
DSAL/SS 2017
VL-04: Rekursionsgleichungen
31/37
Rekursionsbäume
Grundidee
Wir stellen das (wiederholte) Ineinander-Einsetzen als Baum dar,
indem wir Buch führen über das aktuelle Rekursionsargument
und über die nicht-rekursiven Kosten
DSAL/SS 2017
VL-04: Rekursionsgleichungen
32/37
Rekursionsbäume
Grundidee
Wir stellen das (wiederholte) Ineinander-Einsetzen als Baum dar,
indem wir Buch führen über das aktuelle Rekursionsargument
und über die nicht-rekursiven Kosten
Rekursionsbaum
1
Jeder Knoten stellt die Kosten eines Teilproblems dar.
Die Wurzel stellt die zu analysierenden Kosten T (n) dar.
Die Blätter stellen Kosten der Basisfälle dar, z.B. T (0) oder T (1).
DSAL/SS 2017
VL-04: Rekursionsgleichungen
32/37
Rekursionsbäume
Grundidee
Wir stellen das (wiederholte) Ineinander-Einsetzen als Baum dar,
indem wir Buch führen über das aktuelle Rekursionsargument
und über die nicht-rekursiven Kosten
Rekursionsbaum
1
Jeder Knoten stellt die Kosten eines Teilproblems dar.
Die Wurzel stellt die zu analysierenden Kosten T (n) dar.
Die Blätter stellen Kosten der Basisfälle dar, z.B. T (0) oder T (1).
2
DSAL/SS 2017
Wir summieren die Kosten innerhalb jeder Ebene des Baumes.
VL-04: Rekursionsgleichungen
32/37
Rekursionsbäume
Grundidee
Wir stellen das (wiederholte) Ineinander-Einsetzen als Baum dar,
indem wir Buch führen über das aktuelle Rekursionsargument
und über die nicht-rekursiven Kosten
Rekursionsbaum
1
Jeder Knoten stellt die Kosten eines Teilproblems dar.
Die Wurzel stellt die zu analysierenden Kosten T (n) dar.
Die Blätter stellen Kosten der Basisfälle dar, z.B. T (0) oder T (1).
2
Wir summieren die Kosten innerhalb jeder Ebene des Baumes.
3
Gesamtkosten := Summe über die Kosten aller Ebenen.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
32/37
Rekursionsbäume
Grundidee
Wir stellen das (wiederholte) Ineinander-Einsetzen als Baum dar,
indem wir Buch führen über das aktuelle Rekursionsargument
und über die nicht-rekursiven Kosten
Rekursionsbaum
1
Jeder Knoten stellt die Kosten eines Teilproblems dar.
Die Wurzel stellt die zu analysierenden Kosten T (n) dar.
Die Blätter stellen Kosten der Basisfälle dar, z.B. T (0) oder T (1).
2
Wir summieren die Kosten innerhalb jeder Ebene des Baumes.
3
Gesamtkosten := Summe über die Kosten aller Ebenen.
Wichtiger Hinweis
Ein Rekursionsbaum ist nützlich, um eine Lösung zu raten,
die dann mit Hilfe der Substitutionsmethode überprüft werden kann.
Der Baum selbst reicht jedoch nicht als Beweis.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
32/37
Rekursionsbäume: Beispiel (1)
Beispiel
Der Rekursionsbaum von T (n) = 3 · T (n/4) + n sieht etwa so aus:
Aktuelles
Rekursionsargument
T (n/4)
n/4
T (n/16)
n/16
DSAL/SS 2017
T (n/16)
n/16
Nichtrekursive
Kosten
T (n)
n
T (n/4)
n/4
T (n/16)
n/16
T (n/4)
n/4
. . . . . . . . . T (n/16)
n/16
VL-04: Rekursionsgleichungen
T (n/16)
n/16
T (n/16)
n/16
33/37
Rekursionsbäume: Beispiel (2)
T (n)
n
log4 n
T (n/16)
n/16
T (n/4)
n/4
T (n/16)
n/16
n
T (n/4)
n/4
T (n/16)
n/16
T (n/4)
n/4
T (n/16)
n/16
T (1)T (1)T (1)T (1)T (1)T (1)
T (n/16)
n/16
3n/4
T (n/16)
n/16
9n/16
T (1)T (1)T (1)T (1)T (1)T (1)
3log4 n = nlog4 3
DSAL/SS 2017
VL-04: Rekursionsgleichungen
34/37
Rekursionsbäume: Beispiel (2)
T (n)
n
log4 n
T (n/16)
n/16
T (n/4)
n/4
T (n/16)
n/16
n
T (n/4)
n/4
T (n/16)
n/16
T (n/4)
n/4
T (n/16)
n/16
T (1)T (1)T (1)T (1)T (1)T (1)
T (n/16)
n/16
3n/4
T (n/16)
n/16
9n/16
T (1)T (1)T (1)T (1)T (1)T (1)
3log4 n = nlog4 3
log4 (n) −1
T (n) =
X
i=0
| {z }
i
3
log4 (3)
· n + c| · n{z
}
4
| {z }
Gesamtkosten
Summe über Kosten pro
Ebene
alle Ebenen
DSAL/SS 2017
für die Blätter
mit T (1) = c
VL-04: Rekursionsgleichungen
34/37
Rekursionsbäume: Beispiel (3)
Eine obere Schranke für die Komplexität erhält man nun folgendermassen:
log4 (n) −1
T (n)
=
X 3 i
i=0
DSAL/SS 2017
4
· n + c · nlog4 (3)
//Vernachlässigen kleinerer Terme
VL-04: Rekursionsgleichungen
35/37
Rekursionsbäume: Beispiel (3)
Eine obere Schranke für die Komplexität erhält man nun folgendermassen:
log4 (n) −1
T (n)
=
X 3 i
4
i=0
≤
∞ X
3 i
i=0
DSAL/SS 2017
4
· n + c · nlog4 (3)
· n + c · nlog4 (3)
//Vernachlässigen kleinerer Terme
//Geometrische Reihe
VL-04: Rekursionsgleichungen
35/37
Rekursionsbäume: Beispiel (3)
Eine obere Schranke für die Komplexität erhält man nun folgendermassen:
log4 (n) −1
T (n)
=
X 3 i
4
i=0
≤
∞ X
3 i
i=0
≤
DSAL/SS 2017
4
· n + c · nlog4 (3)
· n + c · nlog4 (3)
1
· n + c · nlog4 (3)
1 − (3/4)
//Vernachlässigen kleinerer Terme
//Geometrische Reihe
//Umformen
VL-04: Rekursionsgleichungen
35/37
Rekursionsbäume: Beispiel (3)
Eine obere Schranke für die Komplexität erhält man nun folgendermassen:
log4 (n) −1
T (n)
=
X 3 i
4
i=0
≤
∞ X
3 i
i=0
DSAL/SS 2017
4
· n + c · nlog4 (3)
· n + c · nlog4 (3)
≤
1
· n + c · nlog4 (3)
1 − (3/4)
≤
4 · n + c · nlog4 (3)
//Vernachlässigen kleinerer Terme
//Geometrische Reihe
//Umformen
//Asymptotische Ordnung bestimmen
VL-04: Rekursionsgleichungen
35/37
Rekursionsbäume: Beispiel (3)
Eine obere Schranke für die Komplexität erhält man nun folgendermassen:
log4 (n) −1
T (n)
X 3 i
=
4
i=0
≤
∞ X
3 i
i=0
4
· n + c · nlog4 (3)
· n + c · nlog4 (3)
//Vernachlässigen kleinerer Terme
//Geometrische Reihe
≤
1
· n + c · nlog4 (3)
1 − (3/4)
≤
4 · n + c · nlog4 (3)
//Asymptotische Ordnung bestimmen
∈
O(n)
//Wegen log4 (3) < 1
//Umformen
T (n) ∈ O(n)
DSAL/SS 2017
VL-04: Rekursionsgleichungen
35/37
Rekursionsbäume: Beispiel (4)
Wir können die Substitutionsmethode benutzen, um die Vermutung zu
bestätigen, dass folgendes gilt:
T (n) = 3 · T (n/4) + n impliziert T (n) ≤ d · n.
DSAL/SS 2017
VL-04: Rekursionsgleichungen
36/37
Rekursionsbäume: Beispiel (4)
Wir können die Substitutionsmethode benutzen, um die Vermutung zu
bestätigen, dass folgendes gilt:
T (n) = 3 · T (n/4) + n impliziert T (n) ≤ d · n.
T (n)
DSAL/SS 2017
=
3 · T (n/4) + n
//Induktionshypothese
VL-04: Rekursionsgleichungen
36/37
Rekursionsbäume: Beispiel (4)
Wir können die Substitutionsmethode benutzen, um die Vermutung zu
bestätigen, dass folgendes gilt:
T (n) = 3 · T (n/4) + n impliziert T (n) ≤ d · n.
T (n)
DSAL/SS 2017
=
3 · T (n/4) + n
≤
3 · (d·n/4) + n
//Induktionshypothese
VL-04: Rekursionsgleichungen
36/37
Rekursionsbäume: Beispiel (4)
Wir können die Substitutionsmethode benutzen, um die Vermutung zu
bestätigen, dass folgendes gilt:
T (n) = 3 · T (n/4) + n impliziert T (n) ≤ d · n.
T (n)
=
3 · T (n/4) + n
≤
3 · (d·n/4) + n
3
d + 1 ·n
4
=
DSAL/SS 2017
//Induktionshypothese
//mit d ≥ 4 folgt sofort:
VL-04: Rekursionsgleichungen
36/37
Rekursionsbäume: Beispiel (4)
Wir können die Substitutionsmethode benutzen, um die Vermutung zu
bestätigen, dass folgendes gilt:
T (n) = 3 · T (n/4) + n impliziert T (n) ≤ d · n.
T (n)
=
3 · T (n/4) + n
≤
3 · (d·n/4) + n
3
d + 1 ·n
4
=
≤
//Induktionshypothese
//mit d ≥ 4 folgt sofort:
d·n
Und wir stellen fest,
dass es ein n0 gibt, sodass T (n) ≤ 4·n für n ≥ n0 .
DSAL/SS 2017
VL-04: Rekursionsgleichungen
36/37
Organisatorisches
• Nächste Vorlesung:
Dienstag, Mai 2, 16:15–17:45 Uhr, Aula 1
• Webseite: http://algo.rwth-aachen.de/Lehre/SS17/DSA.php
DSAL/SS 2017
VL-04: Rekursionsgleichungen
37/37