Hallo Welt für Fortgeschrittene

Transkript

1 Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck Programming Systems Group Martensstr Erlangen Germany

2 Gliederung Einführung Definition und Abgrenzung Top-Down und Bottom-Up Anwendungsbeispiele Longest Common Subsequence Optimal Binary Search Trees Komplexität und Optimierung Literatur & Anhang Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 2

3 Hinweis zum gezeigten Code Programmierstil: C++ Folgende (bekannte) Abbreviationen werden benutzt: typedef long long ll; #define FOR(i,a,b) for (int i = (a); i < (b); i++) #define FORD(i,a,b) for (int i = int(b)-1; i >= (a); i--) Zudem wird genutzt: using namespace std; Und aus Platzgründen werden alle #includes weggelassen. Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 3

4 Definition Dynamische Programmierung: Ursprung in der mathematischen Optimierung (Bellmann) Derivat des allgemeinen Rekursionsverfahren Verfahren: Untergliederung eines Problems in mehrere (ggf. überlappende) Teilprobleme Zwischenspeichern und Wiederverwenden von Teilergebnissen Lösung des Gesamtproblems durch geschickte Kombination der gelösten Teilprobleme Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 4

5 Abgrenzung Problemstruktur Optimale Substruktur: Optimale Gesamtlösung ergibt sich aus der optimalen Lösung der Teilprobleme. Also: A optimal & B optimal A B optimal Überlappende Teilprobleme: Es werden Teillösungen mehrfach berechnet, da diese im Rekursionsbaum mehrfach vorkommen. Dies grenzt das Verfahren von Divide & Conquer ab. Beispiel: B A C C D Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 5

6 Kaninchenpopulation Wie viele Kaninchenpaare entstehen im Verlauf eines Jahres aus einem Paar? Wir wissen: Kaninchen gebären erstmals ab dem zweiten Monat Jedes Paar bringt dann jeden Monat ein neues Paar auf die Welt Kaninchen sind unsterblich Lösen wir das Problem graphisch! Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 6

7 Kaninchenpopulation - Grafik Kaninchenbaum: Monat 1: Monat 2: Monat 3: Monat 4: Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 7

8 Kaninchenpopulation - Werte Wir stellen fest: Start: 1 Kaninchenpaar Monat 1: 1 Kaninchenpaar Monat 2: 2 Kaninchenpaare Monat 3: 3 Kaninchenpaare Monat 4: 5 Kaninchenpaare Diese Folge kennen wir doch: Fibonacci Folge Beispiel aus: Liber abaci (Rom 1857) Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 8

9 Fibonacci ohne Dynamische Programmierung Berechnen Sie den n-ten Wert der Fibonacci- Folge. Mathematische Definition (mit n 0): fib n = Naive Lösung (mit n 0): o 1 fib n 1 + fib(n 2), falls n = 0, falls n = 1, sonst ll fib (int n){ if (n == 0 n == 1) return n; return fib(n-1) + fib(n-2); } Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 9

10 Fibonacci ohne Dynamische Programmierung Aufwand fib(5): Zu hoch, da Mehrfachberechnung f(3) f(5) f(4) Überlappende Teilprobleme! f(2) f(1) f(2) f(3) f(0) f(1) f(0) f(1) f(1) f(2) f(0) f(1) Komplexität: O(2 n ) Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 10

11 Geschmacksrichtungen der DP: Top-Down Top-Down: Ausgangspunkt ist der gesuchte Wert (von oben) Rekursiver Abstieg bis zum Basisfall Zwischenspeicherung und Wiederverwendung bereits berechneter Teilergebnisse (Memoization) ll fibs[int_max]; fibs.fill(-1); ll fib_td(int n){ } if (n == 0 n == 1) return n; if (fibs[n] == -1) fibs[n] = fib_td(n-1) + fib_td(n-2); return fibs[n]; Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 11

12 Geschmacksrichtungen der DP: Top-Down Beispiel: fib_td(5) f(5) f(3) f(4) f(2) f(3) f(1) f(2) Komplexität: O(n) Start mit gesuchten Wert f(0) f(1) Aufruf In Tabelle f(5) fibs[4] == -1 X f(4) fibs[3] == -1 X f(3) fibs[2] == -1 X f(2) fibs[1] == -1 X f(1) return 1 f(0) return 0 Memo fibs[2] = 1 f(1) return 1 Memo fibs[3] = 2 f(2) fibs[2] == 1 Memo fibs[4] = 3 f(3) fibs[2] == 2 Memo fibs[5] = 5 Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 12

13 Geschmacksrichtungen der DP: Top-Down Vorteile: Ausschließliche Berechnung nützlicher Teilprobleme Einfache Implementierung durch intuitiven Ansatz Nachteile: Problematischer Speicheraufwand bei hoher Rekursionstiefe (ggf. Stack Overflow) Zusätzlicher Mehraufwand der Speicherung und Abfrage Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 13

14 Geschmacksrichtungen der DP: Bottom-Up Bottom Up: Ausgangspunkt ist die Basis des Problems (von unten) Lösung durch geschickte Strukturierung der Teilprobleme unter Beachtung bereits berechneter Teillösungen Entrekusivierte iterative Fassung des Problems ll fib_bu(int n){ } ll fibs[n+2]; fibs[0] = 0; fibs[1] = 1; FOR(i, 2, n + 1){ } fibs[i] = fibs[i-1] + fibs[i-2]; return fibs[n]; Kann auch vorberechnet werden Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 14

15 Geschmacksrichtungen der DP: Bottom-Up Ggf. Vorausberechnung der nötigen Werte: ll fibs[n_max+2]; void precalculate(){ fibs[0] = 0; fibs[1] = 1; FOR(i, 2, n + 1){ fibs[i] = fibs[i-1] + fibs[i-2]; } } ll fib_bu(int n){ return fibs[n]; } Komplexität: Vorberechnung: Zugriff: O(n) O(1) Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 15

16 Geschmacksrichtungen der DP: Bottom-Up Mischung, welche immer nur unbekannte Werte berechnet: ll fibs[n_max+2]; //initialisiert mit -1 fibs[0] = 0; fibs[1] = 1; ll fib_bu(int n){ if(fibs[n-1]!= -1) return (fibs[n] = fibs[n-1] + fibs[n-2]); FOR(i, 2, n + 1){ fibs[i] = fibs[i-1] + fibs[i-2]; } return fibs[n]; } Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 16

17 Geschmacksrichtungen der DP: Bottom-Up Beispiel: fib_bu(5) fibs[] abgekürzt durch f[] f[5] Ende mit Startwert f[4] f[3] f[2] f[0] f[1] Start mit Basis Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 17

18 Geschmacksrichtungen der DP: Bottom-Up Vorteile: Bei geschickter Programmierung entstehen Laufzeitvorteile Probleme der Rekursion entfallen (Overhead, Overflow, ) Nachteile: Kompliziertere Problemlösung (ggf. weniger intuitiv) Bei Vorberechnung werden auch nicht benötigte Werte berechnet (zudem: Obergrenze muss bekannt sein) Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 18

19 Zusammenfassung Lösen mittels DP Schritte der Dynamischen Programmierung: 1. Analyse o Kann ein Problem in Teilprobleme untergliedert werden? o Führt deren Zusammensetzung zur optimalen Lösung? 2. Mathematische Fixierung o Aufstellen der Rekursionsgleichung o (Pseudocode) 3. Algorithmische Umsetzung o Lösen mittels Top-Down Ansatz o Ggf. Umformung in eine Bottom-Up Lösung 4. Optimierung hinsichtlich Zeit und Platz Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 19

20 Wo sind wir? Einführung Definition und Abgrenzung Top-Down und Bottom-Up Anwendungsbeispiele Longest Common Subsequence Optimal Binary Search Trees Komplexität und Optimierung Literatur & Anhang Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 20

21 Longest Common Subsequence Einführung Problemstellung Gegeben: zwei Zeichenketten X (x 1,, x n ) und Y (y 1,, y m ) Gesucht: längste gemeinsame Folge Z, die identische Zeichen von X und Y in derselben Reihenfolge enthält, wobei Zeichen ausgelassen werden dürfen Beispiele: X = WASSER Y = AERMEL Z = AER X = MUSIK Y = SIMPEL Z = SI! Gieriges Vorgehen (d.h. jeden doppelten Buchstaben sofort nehmen) führt nicht zwingend zum Optimum! Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 21

22 Longest Common Subsequence Anwendung Anwendungsgebiete: Textvergleich (z.b. diff) Unterschiede zweier Programmtexte (Mergen, z.b. Git) Unterschiede von Programmausgaben (ICPC) Bioinformatik Analyse von DNA und Proteinsequenzen Benutzen Generalisierungen von LCS Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 22

23 Longest Common Subsequence Brute Force Problemlösung (naiv, Brute Force): 1. Berechne alle Teilstrings von X oder Y 2. Überprüfe welcher Teilstring in der anderen Folge vorkommt 3. Wähle die längste Kette aus Beispiel: X = CAB Y = ABC Teilstrings von X: Vorkommen in Y: Längste Kette: { C, A, B, CA, CB, AB, CAB } { C, A, B, AB } AB Aufwand: viel zu groß, selbst bei kleinen Beispielen! Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 23

24 Longest Common Subsequence Definitionen Definitionen: X x 1,, x m und Y y 1,, y n zwei Zeichenketten Z z 1,, z q : eine LCS von X und Y X i, Y j, Z k : Präfix von X, Y, Z bis zur Stelle i, j, k c[i, j]: Länge der längsten LCS von X i und Y j Beispiel der Schreibweisen (keine Nullindizierung!): X = SPATZ Y = KATZEN (m = 5, n = 6) x 1 = S y 3 = T X 3 = "SPA" Y 4 = "KATZ" c 3,4 = 1 (LCS = "A") Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 24

25 Longest Common Subsequence Beispiel Wir bestimmen die Länge der LCS: Idee: Wir vergleichen die Wörter beim ersten Zeichen beginnend Sind die Zeichen gleich: Buchstabe kommt in der LCS vor LCS = LCS + 1 Vergleichen der beiden Reststrings Sind die Zeichen unterschiedlich: Höchstens einer der Buchstaben ist in der LCS Wir schauen, ob einer der beiden Reststrings, das Zeichen des anderen Wortes enthält (Fallunterscheidung) Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 25

26 Longest Common Subsequence Rekursiv Mathematisch: lcs(x, Y) = 0 lcs(x i+1, Y j+1 ) + 1 max(lcs X, Y j+1, lcs X i+1, Y ) falls X = 0 Y = 0 falls x i = y j falls x i y j Algorithmisch: int lcs(char * X, char * Y){ } if ( * X == \0 * Y == \0 ) return 0; else if ( * X == * Y){ else return lcs(x+1, Y+1)+ 1; return max(lcs(x, Y+1), lcs(x+1, Y)); Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 26

27 Longest Common Subsequence Rekursiv Worst Case Fall: X = AST Y = UND x 1 y 1 Überlappende Teilprobleme! x 1 y 2 x 2 y 1 x 1 y 3 x 2 y 2 x 2 y 2 x 3 y 1 x 2 y 3 x 3 y 2 x 2 y 3 x 3 y 2 Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 27

28 Longest Common Subsequence Dynamisch int lcs(char * X, char * Y){ if ( * X == \0 * Y == \0 ) return 0; else if ( * X == * Y){ return lcs(x+1, Y+1)+ 1; else return max(lcs(x+1, Y), lcs(x, Y+1)); } Diese intuitive Lösung ist korrekt, aber zu zeitaufwendig. Komplexität ist im Worst Case Ο(2 n ) (keine gleichen Zeichen). Wir lösen das Problem nun mit Bottom-Up DP. Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 28

29 Longest Common Subsequence Bottom Up Beispiel Tafel (bzw. Anhang) Mathematische Definition: c i, j = 0 c i 1, j max(c i, j 1, c[i 1, j]) falls i = 0 j = 0 falls i, j > 0 x i = y j falls i, j > 0 x i y j Diese Formulierung lässt sich wiederum algorithmisch ausdrücken. Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 29

30 Longest Common Subsequence Bottom Up string X = /* */, Y = /* */; ll c[maxm+1][maxn+1]; //initialisiert mit 0 ll LCS() { } FOR(i, 0, X.size()){ } FOR(j, 0, Y.size()){ } if (X[i] == Y[i]){ c[i+1][j+1] = c[i][j] + 1; } else { } c[i+1][j+1] = max(c[i][j+1], c[i+1][j]); return c[x.size()][y.size()]; Komplexität: Ο(N M) Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 30

31 Longest Common Subsequence Vorteile Optimierungen: Wir sparen uns den Fall (X[i] == 0 Y[i] == 0), indem wir eine Nullzeile/-spalte einführen. Wir nutzen Memoization, um Teilergebnisse wiederverwenden zu können. Wir berechnen die Lösung iterativ Bisher berechnet der Algorithmus nur die Länge der längsten gemeinsamen Subsequenz. Um die eigentliche gemeinsame Sequenz herauszufinden, ergänzen wir den Algorithmus um eine Methode, welche die Bottom-Up Tabelle rückwärts nutzt. Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 31

32 Longest Common Subsequence Tabelle Beispiel einer Tabelle: X = OPA Y = TOA x i O P A y i T O A Wir starten bei c n [m]: Gleiche Buchstaben werden sicher genutzt A. Wir betrachten als nächstes Zelle c n 1 m 1. Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 32

33 Longest Common Subsequence Tabelle Beispiel einer Tabelle: X = OPA Y = TOA Weiter bei c n 1 [m 1]: x i O P A y i T O A Bei ungleichen Buchstaben differenzieren wir zwischen den Zeichen von X und Y. Wir nehmen das Maximum der Zellen c n 2 m 1 und c n 1 m 2. Hier c n 2 m 1 = 1. Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 33

34 Longest Common Subsequence Tabelle Beispiel einer Tabelle: X = OPA Y = TOA x i O P A y i T O A Weiter bei c n 2 [m 1]: Gleiche Buchstaben werden sicher genutzt. O Wir betrachten als nächstes c n 3 m 2 Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 34

35 Longest Common Subsequence Tabelle Beispiel einer Tabelle: X = OPA Y = TOA Weiter bei c n 3 [m 2]: x i O P A y i T O A Der Wert ist 0; es kommt also kein neuer Buchstabe mehr dazu. Wir sind fertig! Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 35

36 Longest Common Subsequence Rekonstruktion Wir speichern die Zeichen in w zwischen (Start: w = ) Mathematisch zusammengefasst: f i, j, w = w f(i 1, j 1, x i + w) falls falls falls c i, j = 0 x i = y j x i y j, c i, j 0 Fallunterscheidung bei ungleichem Zeichen: = f(i 1, j, w) f(i, j 1, w) falls falls c i 1, j c[i, j 1] sonst Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 36

37 Longest Common Subsequence Rekonstruktion Algorithmus: string word(ll i, ll j) { if (i==0 j==0) return ; if (X[i-1] == Y[j-1]) return word(i-1, j-1) + X[i-1]; else if (c[i-1][j] >= c[i][j-1]) return word(i-1, j); else return word(i, j-1); } Hier entfällt die Speicherung im Wort w (stattdessen im return). Aufgerufen wird die Funktion mit: word(x.size(), Y.size()) Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 37

38 OBST Optimal Binary Search Trees Der typische Obstbaum: Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 38

39 Optimal Binary Search Trees - Suchmaschine Hello Wir betreiben eine eigene limitierte Suchmaschine, bei der Nutzer nur nach Keywords suchen können: Wir verwalten die Suchanfragen in einem Baum: Auf Grund der letzten Suchanfragen wissen wir wie häufig nach einem Begriff gesucht wurde Knoten enthalten die Suchbegriffe als Key (lexikographische Sortierung) und die zugehörigen Daten (z.b. Text) Für nicht vorhandenen Keywords verwenden wir Dummies als Blätter (#(Dummies) = #(Knoten) + 1) Wie sieht der optimale binäre Suchbaum aus? Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 39

40 Optimal Binary Search Trees - Problemstellung Problemstellung Gegeben: Knoten (k i ) enthalten Daten und Keys Blätter sind Dummy-Elemente (d i ) mit eigenen Keys (es wird nach einen lexikographisch kleineren/größeren Wert gesucht) Keys haben gewisse Wahrscheinlichkeit (p i, q i (Dummy)) Bsp.: k 1 d 1 k 2 d 2 d 3 Knoten = {k 1, k 2 } Daten = {he.html, wo.html} Keys = { Hello, World } p i = {0.3, 0.4} q i = {0.05, 0.1, 0.15} Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 40

41 Optimal Binary Search Trees - Problemstellung Problemstellung Gesucht: Minimale Kosten eines binären Suchbaumes (c baum ) Kosten eines Knoten (c i ) bestimmt sich durch eine Gewichtungsfunktion g (z.b. Tiefe (T(x)) * Wahrscheinlichkeit) Kosten des Baumes ist die Summe der Kosten der Knoten Bsp.: k 1 g x = Tiefe x + 1 Whrs(x) p i = {0.3, 0.4} q i = {0.05, 0.1, 0.15} d 1 k 2 c baum = c i = p i T k i + q i T(d i ) i i i d 2 d 3 Erfolg Misserfolg Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 41

42 Optimal Binary Search Trees Binärer Suchbaum Wiederholung: Binärer Suchbaum: Jeder Knoten hat höchstens zwei Kinder (Teilbäume) Alle Knoten des linken Teilbaumes haben einen kleineren Key als ihr Vaterknoten (gilt rekursiv) Alle Knoten des rechten Teilbaums haben einen größeren Key als ihr Vater (rekursiv) 5 Wurzelknoten Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 42

43 Optimal Binary Search Trees Brute Force Naiver Algorithmus (Brute Force): Stelle alle möglichen BSTs auf (Wurzelvariation) Berechne für jeden BST die Kosten mittels der Gewichtungsfunktion z.b. c baum = i p i T k i + i q i T(d i ) Wähle den Baum mit den geringsten Kosten aus Problem: Anzahl an BST steigt mit Knotenzahl exponentiell an. Also exponentieller Aufwand. Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 43

44 Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 44 Optimal Binary Search Trees Anzahl an BSTs Auswahl an BSTs:

45 Optimal Binary Search Trees Definition Wir definieren also einen Teilbaum BST(i, j): Linker Teilbaum hat Knoten k i,, k r 1 (alle kleineren Keys) Die Wurzel ist k r Rechter Teilbaum hat Knoten k r+1,, k j (alle größeren Keys) Beispiel: BST(2, 6) mit r = 3 ohne Dummies k 3 Wurzelknoten k 2 k 5 Wurzel des rechten Teilbaums k 4 k 6 Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 45

46 Optimal Binary Search Trees Wurzelvariation Wir können alle möglichen BST bestimmen, indem wir rekursiv den Wurzelknoten k r aller Teilbäume variieren. Kosten für BST(i, j) mit variablem r: c i, j = c linkerteilbaum + c rechterteilbaum + Gewichtung = c i, r 1 + c r + 1, j + g i, j Beispiel: r = 1 r = 2 r = 3 k 1 rekursiv k rekursiv 3 k 2 k 1 k 2 k 1 k 3 k 3 k 2 Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 46

47 Optimal Binary Search Trees Kosten von Teilbäumen Kosten für BST(i, j) mit variablem r: c i, j = c linkerteilbaum + c rechterteilbaum + Gewichtung = c i, r 1 + c r + 1, j + g i, j Mit z.b.: Wir nutzen aus: j g i, j = l=i j p l + l=i 1 g i, i 1 = i 1 i 1 l=i p l + l=i 1 q l = q i 1 q l Rekursive Definition: c i, j = q i 1 min c i, r 1 + c r + 1, j + g i, j, falls j = i 1 i r j, falls i j Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 47

48 Optimal Binary Search Trees Kosten von Teilbäumen Rekursive Definition: c i, j = q i 1 min c i, r 1 + c r + 1, j + g i, j, falls j = i 1 i r j, falls i j Algorithmus: ll costbcs(ll i, ll j, ll p[], ll q[]) { } if(j == i-1) return q[i-1]; ll tmp = LLONG_MAX; FOR(r, i, j){ } return tmp; tmp = min (tmp, costbcs(i, r-1, p, q) + costbcs(r+1, j, p, q) + g(i, j, p, q)); Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 48

49 Optimal Binary Search Trees Problem Wobei g die Gewichtungsfunktion ist ll g(ll i, ll j, ll p[], ll q[]) { /*Gewichtung*/ }; Problem: Mehrfachberechnung von Teilbäumen Lösung: Top Down DP Memoization von gefundenen Kosten eines optimalen Teilbaums Auf Grund der Baumstruktur, ist der Baum schon optimal, wenn sein linker und rechter Teilbaum optimal sind Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 49

50 Optimal Binary Search Trees Top Down ll c[max_n][max_n]; //initialisiert mit LLONG_MAX ll costbcs(ll i, ll j, ll p[], ll q[]) { } if(j == i-1) return q[i-1]; if(c[i][j]!= LLONG_MAX) return c[i][j]; ll gewicht = g(i, j, p, q); //nur 1x berechnen FOR(r, i, j){ } c[i][j] = min (c[i][j], costbcs(i, r-1, p, q) + costbcs(r+1, j, p, q) + gewicht); return c[i][j]; Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 50

51 Optimal Binary Search Trees Bottom Up Wir wandeln das Problem nun nach Bottom-Up um. Rekursive Definition: c i [j] = min i r j q i 1 c i [r 1] + c[r + 1][j] + g[i][j], falls j = i 1, falls i j Wir cachen die Funktionsaufrufe, sowie die Gewichtung. Mit: j g i j = l=i j p l + l=i 1 q l = g i j 1 + p j + q j Zudem speichern wir uns in einem Array, die optimalen Wurzeln der Teilbäume um die Lösung rekonstruieren zu können. Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 51

52 Optimal Binary Search Trees Bottom Up ll c[max_n+1][max_n]; //initialisiert mit LLONG_MAX ll g[max_n+1][max_n]; //initialisiert mit 0 ll root[max_n][max_n]; //initialisiert mit 0 void costbcs(ll n, ll p[], ll q[]) { FOR(i, 1, n+1){c[i][i-1]=q[i-1]; g[i][i-1]=q[i-1];} FOR(size, 1, n){ //Sequenzgröße FOR(i, 1, n - size + 1){ //Startpunkt ll j = i + size - 1; g[i][j] = g[i][j-1] + q[j] + p[j]; FOR(r, i, j){ //Wurzel ll tmp = c[i][r-1]+c[r+1][j]+g[i][j]; if(tmp < c[i][j]){ c[i][j] = tmp; root[i][j] = r; } } } } } Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 52

53 Optimal Binary Search Trees Bottom Up Komplexität: O(n 3 ) Rekonstruktion der Lösung: Wurzeln aller optimalen Teilbäume im Array root root[i][j] enthält Index r Mit k r als Wurzel des optimalen Suchbaums Für die Keys k i,, k j Im Folgenden noch ein abschließendes Beispiel, an dem der Bottom-Up Algorithmus erläutert wird. Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 53

54 Optimal Binary Search Trees Beispiel Wir haben folgende Tabelle gegeben: i p i q i Der Algorithmus liefert folgende Pyramide für die Kosten: 5 1 j i Bsp.: c 1 1 = c c g 1 1 = = 0.45 Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 54 q i

55 Optimal Binary Search Trees Beispiel i p i q i Der Algorithmus liefert folgende Pyramide für die Gewichtung: g i j = g i j 1 + p i + q i g i i 1 = q i j 2 5 für i j i 5 g 1 1 = g p 1 + q 1 = = q i Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 55

56 Optimal Binary Search Trees Beispiel i p i q i Der Algorithmus liefert folgende Pyramide für die Wurzel: 1 j i 5 Wir wissen, dass die oberste Wurzel r[1][5] lautet, da diese die Schlüssel k 1,, k 5 umfasst. r[1][5] = 2. k 2 Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 56

57 Optimal Binary Search Trees Beispiel Der Algorithmus liefert folgende Pyramide für die Wurzel: 1 j Der linke Teilbaum umfasst die Knoten k 1,, k 1 (also nur k 1 ): r 1 1 = 1 Der rechte Teilbaum umfasst die Knoten k 3,, k 5 : r 3 5 = i 5 k 2 k 1 k 5 Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 57

58 Optimal Binary Search Trees Beispiel Der Algorithmus liefert folgende Pyramide für die Wurzel: 1 j i 5 k 2 k 1 k 5 k 4 k 3 Der linke Teilbaum von k 5 umfasst die Knoten k 3,, k 4 r 3 4 = 4 Der linke Teilbaum von k 4 umfasst die Knoten k 3,, k 3 : r 3 3 = 3 Jetzt sollte auch klar sein, dass r[i][i] = i Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 58

59 Wo sind wir? Einführung Definition und Abgrenzung Top-Down und Bottom-Up Anwendungsbeispiele Longest Common Subsequence Optimal Binary Search Trees Komplexität und Optimierung Literatur & Anhang Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 59

60 Komplexität des Speicheraufwandes Grundsätzlich kann man die dynamische Programmierung als geschicktes Cachen von Teilergebnissen verstehen. Die Komplexität des Speicheraufwandes lässt sich durch die zu cachenden Parameter der Funktion abschätzen: fib n lcs n, m g(x, y, z) 1D Array 2D Array 3D Array Allgemein: Sei p die Anzahl der (gleich großen) Parameter n, dann beträgt der Speicheraufwand O(n p ) Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 60

61 Optimierung der dynamischen Programmierung Ziel: Optimierung der Zeit- und Speicherkomplexität von Problemen der dynamischen Programmierung Möglichkeit 1: Voraussetzung: Anwendung: Verschmelzen äquivalenter Zustände Existenz vieler gleichwertiger, redundanter Zustände ohne Priorität Einführung von Superzuständen, die eine Äquivalenzklasse von Zuständen entsprechen Diese Methode empfiehlt sich bei Problemen, in denen die Reihenfolge von Zuständen egal ist. Beispiel: (1, 2, 3, 4) ist gleichwertig zu (1, 3, 2, 4) Zustände zu einer Menge verschmelzen {1, 2, 3, 4} Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 61

62 Optimierung der dynamischen Programmierung Möglichkeit 2: Voraussetzung: Anwendung: Eliminieren unnötiger Zustände Existenz derselben Überspringen der Zustände Unnötige Zustände tragen keinen Gewinn für Optimierungsprobleme bei (haben z.b. den Wert 0). Möglichkeit 3: Voraussetzung: Anwendung: Vorberechnung Mehrere Zustände benötigen dieselbe einmalige Berechnung Berechnung vor dem Start der DP Das kann z.b. die Berechnung einer komplizierten mathematischen Konstante sein. Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 62

63 Optimierung der dynamischen Programmierung Es gibt noch weitere Optimierungsmethoden, welche die Performanz einer DP-Lösung noch weiter verbessern können. Beispiele: Nutzen von Matrix-Multiplikation (Fast Exponentiation) Nutzen komplexer Datenstrukturen Segment Trees Binäre Suchbäume Grundsätzlich gilt aber die Bauernregel: Erst den besten Algorithmus selektieren, bevor du anfängst zu optimieren Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 63

64 Prominente DP-Algorithmen Sind unter anderem: Bellman-Ford CYK Traveling Salesperson Problem (TSP) Matrixketten-Multiplikation Longest {Common, Increasing} Subsequence Levenshtein-Distanz Rucksackproblem Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 64

65 Fazit Dynamische Programmierung: Lösen von speziellen Optimierungsproblemen Optimale Teillösungen bilden optimalen Gesamtlösung Überlappende Teilprobleme nur einmal gelöst (Memoization) Ungeeignet für: Sehr große Probleme, d.h. zu große Rekursionstiefe, zu großer Speicheraufwand, zu komplizierte Vorausberechnung Reelle Zahlen als Parameter Probleme mit effizienteren Algorithmen (z.b. Greedy) DP ist ein Austausch von Platz gegen Zeit! Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 65

66 Vielen Dank für eure dankenswerte Aufmerksamkeit! Gibt es noch Fragen? Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 66

67 Wo sind wir? Einführung Definition und Abgrenzung Top-Down und Bottom-Up Anwendungsbeispiele Longest Common Subsequence Optimal Binary Search Trees Komplexität und Optimierung Literatur & Anhang Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 67

68 Literatur Verwendete Materialien: T. Cormen, et al.: Introductions to Algorithms, 3rd edition Julian Brost: Dynamische Programmierung (Hallo Welt, 2013) Moritz Knaut: Dynamische Programmierung (Hallo Welt, 2014) Felix Lugauer: Dynamische Programmierung (Hallo Welt, 2009) Ludwig Höcker: Dynamische Programmierung (Hallo Welt, 2012) Tobias Werth: Dynamic Programming (2004) =697925&start=0&mc= Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 68

69 Literatur Verwendete Materialien: Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 69

70 Literatur Verwendete Materialien: / Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 70

71 Anhang LCS Beispiel Wir bestimmen die Länge der LCS c n, m : Beispiel: X = APO Y = AOT (n = 3, m = 3) Alle LCS mit leeren Worten sind 0: c 1 n, 0 = c 0,1 m = 0 Vergleichen wir X und Y beginnend bei x 1 : x 1 = A = y 1 c 1,1 = 1 + c 0,0 = 1 x 1 = A y 2 = O c 1,2 = max c 0,2, c 1,1 = 1 x 1 = A y 3 = T c 1,3 = max c 0,3, c 1,2 = 1 Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 71

72 Anhang LCS Beispiel Beispiel: X = APO Y = AOT Wir wissen: c 1,0 = c 2,0 = c 3,0 = c 0,1 = c 0,2 = c[0,3] = 0 c 1,1 = c 1,2 = c 1,3 = 1 Vergleichen wir X und Y beginnend bei x 2 : x 2 = P y 1 = A c 2,1 = max c 1,1, c 2,0 = 1 x 2 = P y 2 = O c 2,2 = max c 1,2, c 2,1 = 1 x 2 = P y 3 = T c 2,3 = max c 1,3, c 2,1 = 1 Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 72

73 Anhang LCS Beispiel Beispiel: X = APO Y = AOT Wir wissen: c 1,0 = c 2,0 = c 3,0 = c 0,1 = c 0,2 = c[0,3] = 0 c 1,1 = c 1,2 = c 1,3 = 1 c 2,1 = c 2,2 = c 2,3 = 1 Vergleichen wir X und Y beginnend bei x 3 : x 3 = O y 1 = A c 3,1 = max c 2,1, c 3,0 = 1 x 3 = O = y 2 c 3,2 = c 2,1 + 1 = 2 x 3 = O y 3 = T c 3,3 = max c 2,3, c 3,2 = 2 LCD hat die Länge 2 (c 3,3 = 2) Hallo Welt für Fortgeschrittene Dynamische Programmierung Jan Spieck 73