Hallo Welt für Fortgeschrittene

Transkript

1 Hallo Welt für Fortgeschrittene Dynamische Programmierung Thomas Karmann 4. Juni / 36

2 Übersicht Einführung Definition Anwendung Funktionsweise Grundlagen Memoisation Top-Down Bottom-Up Grenzen Anwendungsbeispiele Allgemeine Vorgehensweise Das Rucksackproblem Longest Common Subsequence Zusammenfassung Literatur 2 / 36

3 Was ist dynamische Programmierung? Definition Dynamische Programmierung ist ein Verfahren zum Lösen komplexer Probleme durch Zerlegung in gleichartige kleinere Teilprobleme. Begriff eingeführt von amerikanischem Mathematiker Richard Bellmann ( ) Grundlage:,,Optimalitätsprinzip von Bellmann 3 / 36

4 Vorraussetzungen Optimale Teilstruktur Überlappende Teilprobleme 4 / 36

5 Vorraussetzung: Optimale Teilstruktur Das Problem lässt sich in gleichartigen kleinere Teilprobleme zerlegen. Optimale Lösung eines Problems lässt sich aus optimalen Lösungen seiner Teilprobleme zusammensetzen. 5 / 36

6 Vorraussetzung: Überlappende Teilprobleme Ein rekursiver Algorithmus muss zur Lösung eines Problems dessen Teilprobleme öfters lösen. 6 / 36

7 Wie funktioniert dynamische Programmierung? Direkte Berechnung der optimalen Lösungen der Teilprobleme. Zusammensetzen der Lösungen zur Lösung des nächstgrößeren Teilproblems. Berechnete Teilergebnisse werden in einer Tabelle gespeichert und müssen dadurch nicht erneut berechnet werden. 7 / 36

8 Memoisation Definition Die Speicherung der Zwischenergebnisse in einer Tabelle nennt man Memoisation. Das grundlegende Verfahren der Funktion wird jedoch beibehalten. 8 / 36

9 Memoisation Definition Die Speicherung der Zwischenergebnisse in einer Tabelle nennt man Memoisation. Das grundlegende Verfahren der Funktion wird jedoch beibehalten. Achtung: Die Funktion muss für gleiche Parameter auch gleiche Ergebnisse liefern! (,,referenzielle Transparenz ) 8 / 36

10 Memoisation: Umsetzung Ablegen der Werte in ein- oder mehrdimensionalen Arrays. Initialisierung des Arrays mit einem,,unset -Wert außerhalb des Lösungsraumes Eventuell Basisfälle gleich in Array speichern. Am Anfang der Funktion zuerst in der Tabelle nachschauen: vielleicht wurde das Ergebniss schon mal berechnet? Ja: Wert auslesen und zurückgeben. Nein: Wert berechnen, in Array speichern und zurückgeben. 9 / 36

11 Der Top-Down Ansatz Kombination aus folgenden Konzepten: Problem wird rekursiv gelöst Optimale Teilstruktur und überlappende Teilprobleme Aufwandsminimierung durch Memoisation 10 / 36

12 Top-Down: Beispiel Definition Die n-te Fibonacci-Zahl ist die Summe ihrer beiden Vorgänger: fib(0) = 0 fib(1) = 1 fib(n) = fib(n 2) + fib(n 1), n > 2 11 / 36

13 Top-Down: Beispiel Definition Die n-te Fibonacci-Zahl ist die Summe ihrer beiden Vorgänger: fib(0) = 0 fib(1) = 1 fib(n) = fib(n 2) + fib(n 1), n > 2 1, 1, 2, 3, 5, 8, 13, 21, 34, / 36

14 Top-Down: Beispiel Naheliegende rekursive Implementierung: int F(int i) { if(i < 1) return 0; if(i == 1) return 1; return F(i - 1) + F(i - 2); } Vorteil: Kompakt und einfach! Nachteil: Exponentieller Aufwand (O(2 n )) durch unnötige Neuberechnungen! 12 / 36

15 Top-Down: Beispiel Rekursive Implementierung mit,,gedächtnis int table[maxval]; 13 / 36

16 Top-Down: Beispiel Rekursive Implementierung mit,,gedächtnis int table[maxval]; #define UNSET -1 memset(table, UNSET, MAXVAL * sizeof(int)); 13 / 36

17 Top-Down: Beispiel Rekursive Implementierung mit,,gedächtnis int table[maxval]; #define UNSET -1 memset(table, UNSET, MAXVAL * sizeof(int)); table[0] = 0; table[1] = 1; int F(int i) { 13 / 36

18 Top-Down: Beispiel Rekursive Implementierung mit,,gedächtnis int table[maxval]; #define UNSET -1 memset(table, UNSET, MAXVAL * sizeof(int)); table[0] = 0; table[1] = 1; int F(int i) { if(table[i]!= 0) return table[i]; 13 / 36

19 Top-Down: Beispiel Rekursive Implementierung mit,,gedächtnis int table[maxval]; #define UNSET -1 memset(table, UNSET, MAXVAL * sizeof(int)); table[0] = 0; table[1] = 1; int F(int i) { if(table[i]!= 0) return table[i]; table[n] = fib(n - 1) + fib(n - 2); return table[n]; } Aufwand nur noch O(n)! 13 / 36

20 Top-Down: Probleme Rekursionstiefe (Stack Overflow) Viele Funktionsaufrufe. 14 / 36

21 Der Bottom-Up Ansatz... funktioniert entgegengesetzt: Zuerst werden die kleineren Teilprobleme gelöst Mithilfe ihrer Ergebnisse errechnet man die Lösungen größerer Teilprobleme. Sukzessives Ausfüllen der Tabelle 15 / 36

22 Bottom-Up: Beispiel int table[maxval]; table[0] = 0; table[1] = 1; int i; for(i = 3; i < MAXVAL; i++) { table[i] = table[i - 2] + table[i - 1]; } int F(int n) { return table[n]; } 16 / 36

23 Bottom-Up Vorteile Nur ein Funktionsaufruf nötig Berechnung erfolgt zu Beginn Nachteile: Umwandlung der Rekursion oftmals nicht so einfach. 17 / 36

24 Grenzen von dynamischer Programmierung Speicherplatz: möglicherweise zu große Funktionswerte Reele Zahlen als Parameter Lösungen mit geringerem Aufwand sind bekannt. 18 / 36

25 Schritte zum DP-Algorithmus 19 / 36

26 Schritte zum DP-Algorithmus 1. Struktur einer optimalen Lösung analysieren: Problem zerlegen, Teilprobleme formulieren. 19 / 36

27 Schritte zum DP-Algorithmus 1. Struktur einer optimalen Lösung analysieren: Problem zerlegen, Teilprobleme formulieren. 2. Rekursionsgleichung für eine optimale Lösung finden 19 / 36

28 Schritte zum DP-Algorithmus 1. Struktur einer optimalen Lösung analysieren: Problem zerlegen, Teilprobleme formulieren. 2. Rekursionsgleichung für eine optimale Lösung finden 3. Implementierung des Top-Down-Ansatzes mithilfe von Memoisation 19 / 36

29 Schritte zum DP-Algorithmus 1. Struktur einer optimalen Lösung analysieren: Problem zerlegen, Teilprobleme formulieren. 2. Rekursionsgleichung für eine optimale Lösung finden 3. Implementierung des Top-Down-Ansatzes mithilfe von Memoisation 4. Wenn möglich: Umwandlung in einen Bottom-Up-Ansatz 19 / 36

30 Schritte zum DP-Algorithmus 1. Struktur einer optimalen Lösung analysieren: Problem zerlegen, Teilprobleme formulieren. 2. Rekursionsgleichung für eine optimale Lösung finden 3. Implementierung des Top-Down-Ansatzes mithilfe von Memoisation 4. Wenn möglich: Umwandlung in einen Bottom-Up-Ansatz 5. Lösungswege aus den Berechnungen konstruieren 19 / 36

31 Das Rucksackproblem Fast schon wieder Semesterferien! Wir fahren in den Urlaub! Unser Auto ist leider sehr klein! Ich glaub wir können nicht alles mitnehmen! Unser Kofferraum besitzt die Kapazität c Wir haben N verschiedene Gepäckstücke zur Verfügung. Jedes unserer Gepäckstücke hat eine Größe s n und einen Wert v n (Die Seife ist z.b. wichtiger als der Bierkasten). Problem: Was sollen wir alles mitnehmen? Der Kofferraum darf nicht überladen werden! Der Gesamtwert seines Inhalts muss maximal sein! 20 / 36

32 Das Rucksackproblem Schritt 1: Struktur einer optimalen Lösung analysieren. Liste von k Gepäckstücken n: L c = (n 1, n 2, n 3,..., n k ) Der Wert des Kofferraums ist die Summe der Werte seiner Gepäckstücke): k w c = i=1 v i 21 / 36

33 Das Rucksackproblem Schritt 2: Rekursionsgleichung für eine optimalen Lösung finden. L c ist für die Kapazität c eine optimale Lösung: wenn wir nun ein beliebiges Gepäckstück aus der Liste entfernen, ist die Restliste eine optimale Lösung für die Kapazität c s ni Vielleicht passt ja noch was anderes rein? Aber Achtung! Die Kapazität c des Kofferrraums darf nicht überschritten werden! Der erhöhte Gesamtwert muss maximal sein! 22 / 36

34 Das Rucksackproblem Schritt 3: Rekursive Implementierung int knapsack(int cap){ int space, max, t; for (int i = 0, max = 0; i < N; i++) if((space = cap - items[i].size) >= 0) if((t = knapsack(space) + items[i].value) > max) max = t; } return max; } 23 / 36

35 Das Rucksackproblem Schritt 3 1/2: Rekursive Implementierung mit Memoisation int knapsack(int cap){ int i, space, max, t; for (i = 0, max = 0; i < N; i++) if ((space = cap - items[i].size) >= 0) if ((t = knapsack(space) + items[i].val) > max){ max = t; } } return max; 24 / 36

36 Das Rucksackproblem Schritt 3 1/2: Rekursive Implementierung mit Memoisation int knapsack(int cap){ int i, space, max, t; if (maxknown[cap]!= UNSET) return maxknown[cap]; for (i = 0, max = 0; i < N; i++) if ((space = cap - items[i].size) >= 0) if ((t = knapsack(space) + items[i].val) > max){ max = t; } } return max; 24 / 36

37 Das Rucksackproblem Schritt 3 1/2: Rekursive Implementierung mit Memoisation int knapsack(int cap){ int i, space, max, t; if (maxknown[cap]!= UNSET) return maxknown[cap]; for (i = 0, max = 0; i < N; i++) if ((space = cap - items[i].size) >= 0) if ((t = knapsack(space) + items[i].val) > max){ max = t; } maxknown[cap] = max; return max; } 24 / 36

38 Das Rucksackproblem Schritt 4: Rekonstruktion des Lösungswegs. Nicht nötig falls uns nur der maximale Wert unseres perfekt gefüllten Kofferraums interessiert Falls wir auch wissen wollen was wir eingepackt haben muss man sich noch zusätzlich die gewählten Gegenstände merken Wir fügen mit jedem Schritt eine neues Stück hinzu welches die verbleibende Kapazität des Kofferraums verkleinert. Dieses Stück bleibt für den Schritt fest und wird nicht mehr geändert. Zu jedem Kapazitätswert des Kofferraums gibt es genau ein eindeutiges Gepäckstück. Wir können uns daher in einem Array die Zuordnung Kapazität Index des Gepäckstücks merken. 25 / 36

39 Das Rucksackproblem Vollständige Lösung des Rucksackproblems mit dynamischer Programmierung: int knapsack (int cap) { int i, space, max, t; if (maxknown[cap]!= UNSET) return maxknown[cap]; for (i = 0, max = 0; i < N; i++) if ((space = cap - items[i].size) >= 0) if ((t = knapsack(space) + items[i].val) > max) { max = t; } maxknown[cap] = max; return max; } 26 / 36

40 Das Rucksackproblem Vollständige Lösung des Rucksackproblems mit dynamischer Programmierung: int knapsack (int cap) { int i, space, max, max_i,t; if (maxknown[cap]!= UNSET) return maxknown[cap]; for (i = 0, max = 0; i < N; i++) if ((space = cap - items[i].size) >= 0) if ((t = knapsack(space) + items[i].val) > max) { max = t; max_i = i; } maxknown[cap] = max; return max; } 26 / 36

41 Das Rucksackproblem Vollständige Lösung des Rucksackproblems mit dynamischer Programmierung: int knapsack (int cap) { int i, space, max, max_i,t; if (maxknown[cap]!= UNSET) return maxknown[cap]; for (i = 0, max = 0; i < N; i++) if ((space = cap - items[i].size) >= 0) if ((t = knapsack(space) + items[i].val) > max) { max = t; max_i = i; } maxknown[cap] = max; itemknown[cap] = items[max_i]; return max; } 26 / 36

42 Ein weiteres Beispiel: Longest Common Subsequence Problembeschreibung: Wir haben zwei Strings A und B. Ziel der Algorithmus ist die Ermittlung der Ähnlichkeit der beiden Strings. Diese ist definiert als die Länge des Strings C, der alle Zeichen enthält die sowohl in A als auch in B vorkommen. Die Zeichen müssen in der selben Reihenfolge, nicht aber zwingenderweise direkt aufeinanderfolgend auftreten. beispiel eisig 4 eisi erlangen langsam 4 lang Anwendungen: diff-tool, Molekularbiologie (ACGT...) 27 / 36

43 Ein weiteres Beispiel: Longest Common Subsequence Problembeschreibung: Wir haben zwei Strings A und B. Ziel der Algorithmus ist die Ermittlung der Ähnlichkeit der beiden Strings. Diese ist definiert als die Länge des Strings C, der alle Zeichen enthält die sowohl in A als auch in B vorkommen. Die Zeichen müssen in der selben Reihenfolge, nicht aber zwingenderweise direkt aufeinanderfolgend auftreten. beispiel eisig 4 eisi erlangen langsam 4 lang Anwendungen: diff-tool, Molekularbiologie (ACGT...) 27 / 36

44 Ein weiteres Beispiel: Longest Common Subsequence Problembeschreibung: Wir haben zwei Strings A und B. Ziel der Algorithmus ist die Ermittlung der Ähnlichkeit der beiden Strings. Diese ist definiert als die Länge des Strings C, der alle Zeichen enthält die sowohl in A als auch in B vorkommen. Die Zeichen müssen in der selben Reihenfolge, nicht aber zwingenderweise direkt aufeinanderfolgend auftreten. beispiel eisig 4 eisi erlangen langsam 4 lang Anwendungen: diff-tool, Molekularbiologie (ACGT...) 27 / 36

45 Longest Common Subsequence Schritt 1: Struktur analysieren. Angenommen wir haben C, die LCS von A und B und es gilt A = n, B = m, C = k Zwei Fälle: 1. Die letzten beiden Zeichen von A und B sind gleich C k 1 ist LCS von A n 1 und B m 1 2. Die letzten beiden Zeichen von A und B sind nicht gleich C k 1 ist max(lcs(a n 1, B m), LCS(A n, B m 1 )) 28 / 36

46 Longest Common Subsequence Schritt 1: Struktur analysieren. Angenommen wir haben C, die LCS von A und B und es gilt A = n, B = m, C = k Zwei Fälle: 1. Die letzten beiden Zeichen von A und B sind gleich C k 1 ist LCS von A n 1 und B m 1 2. Die letzten beiden Zeichen von A und B sind nicht gleich C k 1 ist max(lcs(a n 1, B m), LCS(A n, B m 1 )) Hinweis auf überlappende Teilprobleme! 28 / 36

47 Longest Common Subsequence Schritt 2: Rekursionsgleichung finden. 0 i, k = 0 c[i][k] = c[i 1][k 1] + 1 i, k > 0 A[i] = B[k] max(c[i][k 1], c[i 1][k]) i, k > 0 A[i] B[k] 29 / 36

48 Longest Common Subsequence Schritt 3: Bottom-Up Implementierung int c[maxlen][maxlen]; int lcs(char *s1, int n, char *s2, int m) { int i, j; for (i = 0; i <= n; i++) c[i][0] = 0; for (i = 0; i <= m; i++) c[0][i] = 0; } for (i = 1; i <= n; i++) { for (j = 1; j <= m; j++) { if (s1[i - 1] == s2[j - 1]) { c[i][j] = c[i - 1][j - 1] + 1; } else if (c[i - 1][j] > c[i][j - 1]) { c[i][j] = c[i - 1][j]; else { c[i][j] = c[i][j - 1]; } } } } return c[n][m]; 30 / 36

49 Longest Common Subsequence Schritt 3: Bottom-Up Implementierung. int c[maxlen][maxlen]; int b[maxlen][maxlen]; int lcs(char *s1, int n, char *s2, int m) { int i, j; for (i = 0; i <= n; i++) c[i][0] = 0; for (i = 0; i <= m; i++) c[0][i] = 0; } for (i = 1; i <= n; i++) { for (j = 1; j <= m; j++) { if (s1[i - 1] == s2[j - 1]) { c[i][j] = c[i - 1][j - 1] + 1; b[i][j] = EQUAL; } else if (c[i - 1][j] > c[i][j - 1]) { c[i][j] = c[i - 1][j]; b[i][j] = UP; else { c[i][j] = c[i][j - 1]; b[i][j] = DOWN; } } } } return c[n][m]; 31 / 36

50 Longest Common Subsequence Schritt 4: Rekonstruktion des Lösungsweges. Welche Zeichen bilden die LCS? 1. Wir beginnen bei b[m][n] 2. Wenn b[i][k] == EQUAL 2.1 Rekursion über b[i-1][k-1] starten 2.2 A[i] ausgeben 3. Wenn b[i][k] == UP, Rekursion über b[i][k-1] starten 4. Wenn b[i][k] == LEFT, Rekursion über b[i-1][k] starten 5. Wenn i == 0 oder k == 0, abbrechen 32 / 36

51 Longest Common Subsequence void backtrace(i, k) { if (i == 0) (k == 0) return; else if (b[j][k] == EQUAL) { backtrace(i - 1, k - 1); puts[s1[i]]; } else { if (b[i][k] == UP) backtrace(i, k - 1); else backtrace(i - 1, k); } 33 / 36

52 Typische DP-Algorithmen Longest Increasing Subsequence, Longest Common Substring, Levenshtein-Distanz CYK Bellman-Ford Traveling Salesperson Problem Matrix-Multiplikation Auswahlwerkzeuge in Bildbearbeitungssoftware 34 / 36

53 Zusammenfassung: Was muss ich mir merken? Dynamische Programmierung ergibt Sinn, wenn / 36

54 Zusammenfassung: Was muss ich mir merken? Dynamische Programmierung ergibt Sinn, wenn... du dein Problem rekursiv formulieren kannst. 35 / 36

55 Zusammenfassung: Was muss ich mir merken? Dynamische Programmierung ergibt Sinn, wenn... du dein Problem rekursiv formulieren kannst. du dein Problem in Teilprobleme zerstückeln kannst die sich oft wiederholen. 35 / 36

56 Zusammenfassung: Was muss ich mir merken? Dynamische Programmierung ergibt Sinn, wenn... du dein Problem rekursiv formulieren kannst. du dein Problem in Teilprobleme zerstückeln kannst die sich oft wiederholen. du genügen Speicherplatz zur Zwischenspeicherung (Top-Down) oder Vorberechnung (Bottom-Up) hast. 35 / 36

57 Zusammenfassung: Was muss ich mir merken? Dynamische Programmierung ergibt Sinn, wenn... du dein Problem rekursiv formulieren kannst. du dein Problem in Teilprobleme zerstückeln kannst die sich oft wiederholen. du genügen Speicherplatz zur Zwischenspeicherung (Top-Down) oder Vorberechnung (Bottom-Up) hast. deine Funktionsparameter ganzzahlig sind. 35 / 36

58 Zusammenfassung: Was muss ich mir merken? Dynamische Programmierung ergibt Sinn, wenn... du dein Problem rekursiv formulieren kannst. du dein Problem in Teilprobleme zerstückeln kannst die sich oft wiederholen. du genügen Speicherplatz zur Zwischenspeicherung (Top-Down) oder Vorberechnung (Bottom-Up) hast. deine Funktionsparameter ganzzahlig sind. du keine bessere Idee hast. 35 / 36

59 Literatur T. Cormen u. A. Introduction To Algorithms MIT Press, 2001 R. Sedgewick Algorithmen in C++ Pearsons Studium, 2002 Tobias Werth Dynamische Programmierung Hallo Welt für Fortgeschrittene, 2004 Rainer Müller Dynamische Programmierung Hallo Welt für Fortgeschrittene, 2008 Wikipedia Dynamic Programming programming 36 / 36