Dynamische Programmierung Claudia Gerhold 9.5.6 Claudia Gerhold Dynamische Programmierung 9.5.6 / 4
Agenda Einführung Dynamische Programmierung Top-Down Ansatz mit Memoization Bottom-Up Ansatz 3 Anwendungsbeispiele für DP Longest Common Subsequence (LCS) Levenshtein-Distanz Klammerung von Matrizenprodukten 4 Fazit Claudia Gerhold Dynamische Programmierung 9.5.6 / 4
Einführung Claudia Gerhold Dynamische Programmierung 9.5.6 3 / 4
Beispiel Fibonacci Zahlen,,,, 3, 5, 8, 3,,... Fib() = Fib() = Fib(i) = Fib(i ) + Fib(i ), i > Claudia Gerhold Dynamische Programmierung 9.5.6 4 / 4
Rekursive Implementierung p u b l i c c l a s s F i b o n a c c i { s t a t i c l o n g compute ( i n t i ) { 3 i f ( i <= ) { 4 r e t u r n ; 5 } e l s e i f ( i == ) { 6 r e t u r n ; 7 } e l s e { 8 r e t u r n compute ( i ) + compute ( i ) ; 9 } } } Claudia Gerhold Dynamische Programmierung 9.5.6 5 / 4
Teilergebnisse mehrfach berechnen Fib(5) Fib(4) Fib(3) Fib(3) Fib() Fib() Fib() Fib() Fib() Fib() Fib() Fib() Fib() Fib() Fib() Quelle: vgl. http://programmingwiki.de/images/b/be/erklaerung fib.png Claudia Gerhold Dynamische Programmierung 9.5.6 6 / 4
Iterative Implementierung p u b l i c c l a s s F i b o n a c c i { s t a t i c l o n g compute ( i n t i ) { 3 i f ( i == ) { r e t u r n } 4 e l s e i f ( i == ) { r e t u r n } ; 5 6 i n t f i r s t =, second =, r e s u l t = ; 7 f o r ( i n t j =, j < i ; j ++) { 8 r e s u l t = f i r s t + second ; 9 f i r s t = second ; second = r e s u l t ; } r e t u r n r e s u l t ; 3 } 4 } Claudia Gerhold Dynamische Programmierung 9.5.6 7 / 4
Laufzeit-Vergleich Rekursiv vs. Iterativ Rekursive Variante ist übersichtlicher Laufzeiten bei n = 5: rekursiv: 73,35 s iterativ:,5 ms Aufwand: rekursiv: n O( n ) iterativ: n O(n) Claudia Gerhold Dynamische Programmierung 9.5.6 8 / 4
Laufzeit-Vergleich Rekursiv vs. Iterativ Rekursive Variante ist übersichtlicher Laufzeiten bei n = 5: rekursiv: 73,35 s iterativ:,5 ms Aufwand: rekursiv: n O( n ) iterativ: n O(n) Wie kann noch optimiert werden? Claudia Gerhold Dynamische Programmierung 9.5.6 8 / 4
Dynamische Programmierung Claudia Gerhold Dynamische Programmierung 9.5.6 9 / 4
Historie Richard Ernest Bellman, Mathematiker *9.8.9 (Brooklyn) 9.3.984 (Los Angeles) Paper: u.a. Theory of Dynamic Programming (954) Lösen von Optimierungsproblemen Memoization: Merken berechneter Werte Reduzierung des Rechenaufwands Quelle: https://en.wikipedia.org/ wiki/richard E. Bellman#/media/ File:Richard Ernest Bellman.jpg Claudia Gerhold Dynamische Programmierung 9.5.6 / 4
Anwendung dynamischer Programmierung Optimierungsprobleme mit gleichartigen Teilproblemen überlappenden Teilproblemen Algorithmus Teile Problem in kleinere auf Löse die Teilprobleme Merke Lösungen der Teilprobleme Kombiniere Lösungen zur Gesamtlösung Varianten Top-Down Ansatz Bottom-Up Ansatz Claudia Gerhold Dynamische Programmierung 9.5.6 / 4
Memoization Erweitern des Programmcodes um Tabelle Vorinitialisierung mit Wert außerhalb des Lösungsraums Look-up in Tabelle Berechnung nur, wenn nicht in Tabelle Claudia Gerhold Dynamische Programmierung 9.5.6 / 4
Top-Down Ansatz p u b l i c c l a s s F i b o n a c c i { s t a t i c l o n g cp ( i n t i, l o n g [ ] t ) { 3 i f ( i <= ) { r e t u r n ; } 4 e l s e { 5 i f ( i == ) { r e t u r n ; } 6 e l s e { 7 i f ( t [ i ]!= ) { 8 r e t u r n t [ i ]; 9 } e l s e { t [ i ] = cp ( i, t ) + cp ( i, t ) ; r e t u r n t [ i ]; } 3 } 4 } 5 } 6 } Claudia Gerhold Dynamische Programmierung 9.5.6 3 / 4
Neuer Aufrufbaum Fib(5) Fib(4) Fib(3) Fib(3) Fib() Fib() Fib() Fib() Fib() Quelle: vgl. http://programmingwiki.de/images/b/be/erklaerung fib.png Claudia Gerhold Dynamische Programmierung 9.5.6 4 / 4
Bottom-Up Ansatz p u b l i c c l a s s F i b o n a c c i { s t a t i c p u b l i c l o n g compute ( i n t x ) { 3 l o n g t a b l e [ ] = new l o n g [ x + ] ; 4 t a b l e [ ] = ; 5 t a b l e [ ] = ; 6 f o r ( i n t i = ; i < x + ; i ++) { 7 t a b l e [ i ] = t a b l e [ i ] + t a b l e [ i ] ; 8 } 9 r e t u r n t a b l e [ x ] ; } } Claudia Gerhold Dynamische Programmierung 9.5.6 5 / 4
Laufzeit-Vergleich Laufzeiten bei n = 5: Top-Down mit Memoization:,96 ms Bottom-Up:, ms Aufwand: rekursiv: n O(n) iterativ: n O(n) Claudia Gerhold Dynamische Programmierung 9.5.6 6 / 4
Anwendungsbeispiele für Dynamische Programmierung Claudia Gerhold Dynamische Programmierung 9.5.6 7 / 4
Longest Common Subsequence Problemstellung Gegeben: Strings: x(x, x,..., x i ), y(y, y,..., y j ) Gesucht: String maximaler Länge, ist Teilsequenz von x und y Anwendung: Analyse von Gen-Sequenzen Reihenfolge Zeichen ist relevant Zeichen dürfen übersprungen werden Je länger die gefundene Sequenz, desto ähnlicher sind sich x und y Claudia Gerhold Dynamische Programmierung 9.5.6 8 / 4
Beispiel X = < A, B, C, B, D, A, B > Y = < B, D, C, A, B, A > X Claudia Gerhold Dynamische Programmierung 9.5.6 9 / 4
Beispiel X = < A, B, C, B, D, A, B > Y = < B, D, C, A, B, A > Z = < B, D, A > Länge: 3 Claudia Gerhold Dynamische Programmierung 9.5.6 9 / 4
Beispiel X = < A, B, C, B, D, A, B > Y = < B, D, C, A, B, A > Z = < B, C, B, A > Länge: 4 Claudia Gerhold Dynamische Programmierung 9.5.6 9 / 4
Beispiel X = < A, B, C, B, D, A, B > Y = < B, D, C, A, B, A > Z 3 = < B, D, A, B > Länge: 4 Claudia Gerhold Dynamische Programmierung 9.5.6 9 / 4
Beispiel Z = < B, C, B, A > Länge: 4 Z 3 = < B, D, A, B > Länge: 4 X Z und Z 3 sind längste gemeinsame Teilsquenzen von X und Y. Claudia Gerhold Dynamische Programmierung 9.5.6 9 / 4
Brute-Force Aufzählen aller Teilsequenzen von x Für jede Teilsequenz prüfen, ob in y enthalten Merke längste gemeinsame Teilsequenz x besitzt x Teilsequenzen exponenzielle Laufzeit Claudia Gerhold Dynamische Programmierung 9.5.6 / 4
Herleitung Rekursionsgleichung x i (y j ) ist Präfix von x(y) bis inkl. Stelle i(j) z(z, z,..., z k ) sei LCS von x und y Erinnerung: x(x, x,..., x m ) y(y, y,..., y n ) Fälle: Falls x[i] = y[j], dann z[k] = x[i] = y[j], z[k-] ist LCS von x[i-] und y[j-] oder Falls x[i] y[j], dann impliziert z[k] x[i], z[k] ist LCS von x[i-] und y (analog für z[k] y[j]) Claudia Gerhold Dynamische Programmierung 9.5.6 / 4
Rekursionsgleichung, i =, j = c[i][j] = c[i [j ] +, x i = y i max(c[i][j ], c[i ][j]), x i y i Überlappende Teilprobleme: Teilergebnisse werden mehrfach berechnet Optimale Teilstruktur: Bereits berechnetes Teilergebnis ist für sich eine optimale Lösung Anwendung dynamischer Programmierung: Bottom-Up Berechnung. Tabelle zur Ermittlung der Länge der LCS. Tabelle für Rekonstruktion Claudia Gerhold Dynamische Programmierung 9.5.6 / 4
Arbeitsweise j 3 4 5 6 i B D C A B A A B 3 C 4 B 5 D 6 A 7 B Rekursionsgleichung: c[i][j] = {, i =, j = c[i [j ] +, x i = y i max(c[i][j ], c[i ][j]), x i y i Claudia Gerhold Dynamische Programmierung 9.5.6 3 / 4
Arbeitsweise j 3 4 5 6 i B D C A B A A B 3 C 4 B 5 D 6 A 7 B Rekursionsgleichung: c[i][j] = {, i =, j = c[i [j ] +, x i = y i max(c[i][j ], c[i ][j]), x i y i i =, j = x[i] = A y[j] = B x i y j max(, ) = Claudia Gerhold Dynamische Programmierung 9.5.6 3 / 4
Arbeitsweise j 3 4 5 6 i B D C A B A A B 3 C 4 B 5 D 6 A 7 B Rekursionsgleichung: c[i][j] = {, i =, j = c[i [j ] +, x i = y i max(c[i][j ], c[i ][j]), x i y i i =, j = x[i] = A y[j] = D x i y j max(, ) = Claudia Gerhold Dynamische Programmierung 9.5.6 3 / 4
Arbeitsweise j 3 4 5 6 i B D C A B A A B 3 C 4 B 5 D 6 A 7 B Rekursionsgleichung: c[i][j] = {, i =, j = c[i [j ] +, x i = y i max(c[i][j ], c[i ][j]), x i y i i =, j = 3 x[i] = A y[j] = C x i y j max(, ) = Claudia Gerhold Dynamische Programmierung 9.5.6 3 / 4
Arbeitsweise j 3 4 5 6 i B D C A B A A B 3 C 4 B 5 D 6 A 7 B Rekursionsgleichung: c[i][j] = {, i =, j = c[i [j ] +, x i = y i max(c[i][j ], c[i ][j]), x i y i i =, j = 4 x[i] = A y[j] = A x i = y j + = Claudia Gerhold Dynamische Programmierung 9.5.6 3 / 4
Arbeitsweise j 3 4 5 6 i B D C A B A A B 3 C 4 B 5 D 6 A 7 B Rekursionsgleichung: c[i][j] = {, i =, j = c[i [j ] +, x i = y i max(c[i][j ], c[i ][j]), x i y i i =, j = 5 x[i] = A y[j] = B x i y j max(, ) = Claudia Gerhold Dynamische Programmierung 9.5.6 3 / 4
Arbeitsweise j 3 4 5 6 i B D C A B A A B 3 C 4 B 5 D 6 A 7 B Rekursionsgleichung: c[i][j] = {, i =, j = c[i [j ] +, x i = y i max(c[i][j ], c[i ][j]), x i y i i =, j = 6 x[i] = A y[j] = A x i = y j + = Claudia Gerhold Dynamische Programmierung 9.5.6 3 / 4
Arbeitsweise j 3 4 5 6 i B D C A B A A B 3 C 4 B 3 3 5 D 3 3 6 A 3 3 4 7 B 3 4 4 Rekursionsgleichung: c[i][j] = {, i =, j = c[i [j ] +, x i = y i max(c[i][j ], c[i ][j]), x i y i Claudia Gerhold Dynamische Programmierung 9.5.6 3 / 4
Arbeitsweise j 3 4 5 6 i B D C A B A A B 3 C 4 B 3 3 5 D 3 3 6 A 3 3 4 7 B 3 4 4 Rekursionsgleichung: c[i][j] = {, i =, j = c[i [j ] +, x i = y i max(c[i][j ], c[i ][j]), x i y i BCBA Claudia Gerhold Dynamische Programmierung 9.5.6 3 / 4
Aufwandsbetrachtung Tabelle n m n = x.length + m = y.length + Bottom-Up O(n m) Rekursive Rekonstruktion des LCS O(n + m) Claudia Gerhold Dynamische Programmierung 9.5.6 4 / 4
Levenshtein-Distanz Problemstellung Gegeben: Strings: s und s Gesucht: minimale Anzahl von Änderungen um s in s zu transformieren Editieroperationen INSERT DELETE REPLACE MATCH Einsatzgebiet: u.a. Plagiatscheck Editskript: Folge von Editieroperationen, die Überführung von s in s bewirken sind nicht eindeutig können unterschiedlich lang sein Länge: Anzahl der Editieroperationen Claudia Gerhold Dynamische Programmierung 9.5.6 5 / 4
Beispiel Transformiere Matratze in Katze: M a t r a t z e = = x x x K a t z e Anzahl Operationen: 6 Editskript: REPLACE, MATCH, MATCH, REPLACE, REPLACE, DELETE, DELETE, DELETE Claudia Gerhold Dynamische Programmierung 9.5.6 6 / 4
Beispiel Transformiere Matratze in Katze: M a t r a t z e x x x = = = = K a t z e Anzahl Operationen: 4 Editskript: DELETE, DELETE, DELETE, REPLACE, MATCH, MATCH, MATCH, MATCH Claudia Gerhold Dynamische Programmierung 9.5.6 6 / 4
Rekursionsgleichung d[i ][j ] +, match (s i = s i ) d[i][j ] +, delete d[i][j] = min d[i ][j] +, insert d[i ][j ] +, replace m = s, n = s d[i][] = i, i m d[][j] = j, j n Claudia Gerhold Dynamische Programmierung 9.5.6 7 / 4
Arbeitsweise i j M a t r a t z e 3 4 5 6 7 8 K a t 3 z 4 e 5 Rekursionsgleichung: d[i ][j ] +, match d[i][j ] +, delete d[i][j] = min d[i ][j] +, insert d[i ][j ] +, replace initialisiere Tabelle (trivialer Fall) s oder s sind leer für Transformation sind s.length bzw. s.length Operationen nötig Claudia Gerhold Dynamische Programmierung 9.5.6 8 / 4
Arbeitsweise i j M a t r a t z e 3 4 5 6 7 8 K a t 3 z 4 e 5 Rekursionsgleichung: d[i ][j ] +, match d[i][j ] +, delete d[i][j] = min d[i ][j] +, insert d[i ][j ] +, replace i=, j= s = K, s = M, K M d[][] = min(,, ) + = Claudia Gerhold Dynamische Programmierung 9.5.6 8 / 4
Arbeitsweise i j M a t r a t z e 3 4 5 6 7 8 K 3 4 5 6 7 8 a t 3 z 4 e 5 Rekursionsgleichung: d[i ][j ] + d[i][j ] + d[i][j] = min d[i ][j] + d[i ][j ] + i=[], j=[..8], match, delete, insert, replace Claudia Gerhold Dynamische Programmierung 9.5.6 8 / 4
Arbeitsweise i j M a t r a t z e 3 4 5 6 7 8 K 3 4 5 6 7 8 a t 3 z 4 e 5 Rekursionsgleichung: d[i ][j ] +, match d[i][j ] +, delete d[i][j] = min d[i ][j] +, insert d[i ][j ] +, replace i=[], j[] s = a, s = M, a M d[][] = min(,, ) + = Claudia Gerhold Dynamische Programmierung 9.5.6 8 / 4
Arbeitsweise i j M a t r a t z e 3 4 5 6 7 8 K 3 4 5 6 7 8 a t 3 z 4 e 5 Rekursionsgleichung: d[i ][j ] + d[i][j ] + d[i][j] = min d[i ][j] + d[i ][j ] + i=[], j[] s = a, s = a, a = a d[][] = + =, match, delete, insert, replace Claudia Gerhold Dynamische Programmierung 9.5.6 8 / 4
Arbeitsweise i j M a t r a t z e 3 4 5 6 7 8 K 3 4 5 6 7 8 a 3 4 5 6 7 t 3 3 3 4 5 6 z 4 4 3 3 4 4 5 e 5 5 4 3 3 3 4 5 4 Rekursionsgleichung: d[i ][j ] +, match d[i][j ] +, delete d[i][j] = min d[i ][j] +, insert d[i ][j ] +, replace d[m][n], enthält minimale Anzahl an Operationen d[5][8] = 4 Claudia Gerhold Dynamische Programmierung 9.5.6 8 / 4
Rekonstruktion eines minimalen Editskripts i j M a t r a t z e 3 4 5 6 7 8 K 3 4 5 6 7 8 a 3 4 5 6 7 t 3 3 3 4 5 6 z 4 4 3 3 4 4 5 e 5 5 4 3 3 3 4 5 4 Rekursionsgleichung: d[i ][j ] +, match d[i][j ] +, delete d[i][j] = min d[i ][j] +, insert d[i ][j ] +, replace Editskript: REPLACE, MATCH, MATCH, INSERT, INSERT, INSERT, MATCH, MATCH Claudia Gerhold Dynamische Programmierung 9.5.6 9 / 4
Gewichtete Levenshtein-Distanz Unterschiedliche Gewichtung der Operationen Zur Vermeidung bestimmter Operation Claudia Gerhold Dynamische Programmierung 9.5.6 3 / 4
Aufwandsbetrachtung Tabelle m n m = string.length() + n = string.length() + Zeitaufwand ist O(m n) Platzbedarf ist ebenfalls O(m n) Claudia Gerhold Dynamische Programmierung 9.5.6 3 / 4
Klammerung von Matrizenprodukten Problemstellung Gegeben: Folge von Matrizen (A, A,..., A n ) mit verschiedenen Dimensionen Gesucht: Produkt A A... A n Möglichst effizient: mit minimaler Anzahl skalarer Operationen berechnen Matrixmultiplikation ist assoziativ: Optimierung durch geschickte Klammerung möglich Claudia Gerhold Dynamische Programmierung 9.5.6 3 / 4
Beispiel Drei Matrizen: A R 3, B R 3 5, C R 5 6 Zwei Möglichkeiten der Klammerung : ((A B) C)bzw.(A (B C)) ((A B) C) = ( 3 5) + ( 5 6) = 45 (A (B C)) = (3 5 6) + ( 3 6) = 7 Claudia Gerhold Dynamische Programmierung 9.5.6 33 / 4
Beispiel Drei Matrizen: A R 3, B R 3 5, C R 5 6 Zwei Möglichkeiten der Klammerung : ((A B) C)bzw.(A (B C)) ((A B) C) = ( 3 5) + ( 5 6) = 45 (A (B C)) = (3 5 6) + ( 3 6) = 7 Anzahl skalarer Multiplikationen minimal halten Claudia Gerhold Dynamische Programmierung 9.5.6 33 / 4
Bestimmung minimaler Anzahl skalarer Operationen (A i... A k ) (A k +... A j ), (i j) i = j: keine Kosten (keine Multiplikation, da nur eine Matrix) i < j: Teilen des Matrixprodukt an k (Position nach der geklammert wird) es gilt i k < j: (A i... A k ) (A k +... A j ) Berechnung Matrizen (A i...a k ) und (A k+...a j ), dann Multiplikation der Ergebnisse um endgültiges Produkt A i...a j zu erhalten Kosten: Kosten Berechnung (A i... A k ) + Kosten Berechnung (A k+... A j ) + Kosten der letzten Multiplikation In jedem Schritt wird k gesucht, so dass Kosten minimal sind Claudia Gerhold Dynamische Programmierung 9.5.6 34 / 4
Rekursionsgleichung m[i][j] = {, wenn i=j min i k<j (m[i][k] + m[k + ][j] + p i p k p j ), wenn i<j m[i][j] ist die Anzahl der minimal notwendigen skalaren Operationen m[][n] minimale Anzahl skalarer Operationen für Gesamtproblem Matrix A hat Dimension p i p i Für Berechnung des Matrixprodukts sind p i p k p j skalare Operationen notwendig Claudia Gerhold Dynamische Programmierung 9.5.6 35 / 4
Beispiel A R 6 A R A 3 R 3 A 4 R 3 A 5 R 5 A 6 R 5 8 p = [6,,, 3,, 5, 8] i j 3 4 5 6 3 4 5 6 Rekursionsgleichung: m[i][j] = {, wenn i=j min i k<j (m[i][k] + m[k + ][j] +p i p k p j ), wenn i<j m[i][j] = keine Kosten (trivialer Fall) Claudia Gerhold Dynamische Programmierung 9.5.6 36 / 4
Beispiel A R 6 A R A 3 R 3 A 4 R 3 A 5 R 5 A 6 R 5 8 p = [6,,, 3,, 5, 8] i j 3 4 5 6 3 4 5 6 Rekursionsgleichung: m[i][j] = {, wenn i=j min i k<j (m[i][k] + m[k + ][j] +p i p k p j ), wenn i<j i =, j =, i k < j k = m[][] = m[][] + m[][] + p p p m[][] = ++6 = 44 Claudia Gerhold Dynamische Programmierung 9.5.6 36 / 4
Beispiel A R 6 A R A 3 R 3 A 4 R 3 A 5 R 5 A 6 R 5 8 p = [6,,, 3,, 5, 8] i j 3 4 5 6 44 3 4 5 6 Rekursionsgleichung: m[i][j] = {, wenn i=j min i k<j (m[i][k] + m[k + ][j] +p i p k p j ), wenn i<j i =, j =, i k < j k = m[][] = m[][] + m[][] + p p p m[][] = ++6 = 44 kein weiteres k Claudia Gerhold Dynamische Programmierung 9.5.6 36 / 4
Beispiel A R 6 A R A 3 R 3 A 4 R 3 A 5 R 5 A 6 R 5 8 p = [6,,, 3,, 5, 8] i j 3 4 5 6 44 3 4 5 6 Rekursionsgleichung: m[i][j] = {, wenn i=j min i k<j (m[i][k] + m[k + ][j] +p i p k p j ), wenn i<j i =, j = 3, i k < j k = m[][3] = m[][] + m[3][3] + p p p 3 m[][3] = + + 3 = 7 Claudia Gerhold Dynamische Programmierung 9.5.6 36 / 4
Beispiel A R 6 A R A 3 R 3 A 4 R 3 A 5 R 5 A 6 R 5 8 p = [6,,, 3,, 5, 8] i j 3 4 5 6 44 7 3 4 5 6 Rekursionsgleichung: m[i][j] = {, wenn i=j min i k<j (m[i][k] + m[k + ][j] +p i p k p j ), wenn i<j i =, j = 3, i k < j k = m[][3] = m[][] + m[3][3] + p p p 3 m[][3] = + + 3 = 7 kein weiteres k Claudia Gerhold Dynamische Programmierung 9.5.6 36 / 4
Beispiel A R 6 A R A 3 R 3 A 4 R 3 A 5 R 5 A 6 R 5 8 p = [6,,, 3,, 5, 8] i j 3 4 5 6 44 7 3 4 5 6 Rekursionsgleichung: m[i][j] = {, wenn i=j min i k<j (m[i][k] + m[k + ][j] +p i p k p j ), wenn i<j i =, j = 3, i k < j k = m[][3] = m[][] + m[][3] + p p p 3 m[][3] = +7+6 3 = 936 Claudia Gerhold Dynamische Programmierung 9.5.6 36 / 4
Beispiel A R 6 A R A 3 R 3 A 4 R 3 A 5 R 5 A 6 R 5 8 p = [6,,, 3,, 5, 8] i j 3 4 5 6 44 936 7 3 4 5 6 Rekursionsgleichung: m[i][j] = {, wenn i=j min i k<j (m[i][k] + m[k + ][j] +p i p k p j ), wenn i<j i =, j = 3, i k < j k = m[][3] = m[][] + m[3][3] + p p p 3 m[][3] = 44 + + 6 3 = 8 Claudia Gerhold Dynamische Programmierung 9.5.6 36 / 4
Beispiel A R 6 A R A 3 R 3 A 4 R 3 A 5 R 5 A 6 R 5 8 p = [6,,, 3,, 5, 8] i j 3 4 5 6 44 936 7 3 4 5 6 Rekursionsgleichung: m[i][j] = {, wenn i=j min i k<j (m[i][k] + m[k + ][j] +p i p k p j ), wenn i<j i =, j = 3, i k < j k = m[][3] = m[][] + m[3][3] + p p p 3 m[][3] = 44 + + 6 3 = 8 kein weiteres k min(936, 8) Claudia Gerhold Dynamische Programmierung 9.5.6 36 / 4
Beispiel A R 6 A R A 3 R 3 A 4 R 3 A 5 R 5 A 6 R 5 8 p = [6,,, 3,, 5, 8] i j 3 4 5 6 44 936 6 76 68 7 8 5 788 3 6 45 5 4 5 4 5 9 6 Rekursionsgleichung: m[i][j] = {, wenn i=j min i k<j (m[i][k] + m[k + ][j] +p i p k p j ), wenn i<j Der optimale Wert steht in m[][6] Es werden 68 skalare Operationen benötigt Claudia Gerhold Dynamische Programmierung 9.5.6 36 / 4
Rekonstruktion optimaler Klammerung i j 3 4 5 6 3 3 3 3 3 3 3 3 3 3 4 4 5 5 5 6 Rekursionsgleichung: m[i][j] = {, wenn i=j min i k<j (m[i][k] + m[k + ][j] +p i p k p j ), wenn i<j s[][6], da hier in m der optimale Wert steht optimaler Wert bei k = 3 Klammerung nach A 3 (A A A 3 ) (A 4 A 5 A 6 ) Claudia Gerhold Dynamische Programmierung 9.5.6 37 / 4
Rekonstruktion optimaler Klammerung i j 3 4 5 6 3 3 3 3 3 3 3 3 3 3 4 4 5 5 5 6 Rekursionsgleichung: m[i][j] = {, wenn i=j min i k<j (m[i][k] + m[k + ][j] +p i p k p j ), wenn i<j s[][3], optimales Ergebnis für (A A A 3 ) optimaler Wert bei k = Klammerung nach A (A (A A 3 )) (A 4 A 5 A 6 ) Claudia Gerhold Dynamische Programmierung 9.5.6 37 / 4
Rekonstruktion optimaler Klammerung i j 3 4 5 6 3 3 3 3 3 3 3 3 3 3 4 4 5 5 5 6 Rekursionsgleichung: m[i][j] = {, wenn i=j min i k<j (m[i][k] + m[k + ][j] +p i p k p j ), wenn i<j s[4][6], optimales Ergebnis für (A 4 A 5 A 6 ) optimaler Wert bei k = 5 Klammerung nach A 5 (A (A A 3 )) ((A 4 A 5 ) A 6 ) Claudia Gerhold Dynamische Programmierung 9.5.6 37 / 4
Aufwandsbetrachtung Tabelle n n, n = Anzahl Matrizen Größe Tabelle Aufwand pro Eintrag Zeitaufwand ist O(n n) = O(n 3 ) Claudia Gerhold Dynamische Programmierung 9.5.6 38 / 4
Fazit Wann dynamische Programmierung anwenden? Problem rekursiv formulierbar Optimale Teilstruktur Überlappende Teilprobleme Top-Down mit Memoization vs. Bottom-Up Bottom-Up: im Allgemeinen schneller Bottom-Up: keinen Verwaltungsaufwand für Rekursionen Wenn nicht alle Teilergebnisse benötigt werden, ist Top-Down besser Wann dynamische Programmierung nicht anwenden? Anzahl Funktionswerte zu groß Speicherbedarf für Tabelle zu groß Effizientere Verfahren bekannt (z.b. Formel) Claudia Gerhold Dynamische Programmierung 9.5.6 39 / 4
Vielen Dank für eure Aufmerksamkeit! Gibt es Fragen? Claudia Gerhold Dynamische Programmierung 9.5.6 4 / 4
Quellen T. Cormen et al., Introduction To Algorithms, MIT Press, 9 https://www.informatik.uni-erlangen.de/teaching/ SS/HalloWelt/DP_.pdf https://www.informatik.uni-erlangen.de/en/teaching/ SS5/HalloWelt/dyn_programming.beamer.pdf http://zach.in.tu-clausthal.de/teaching/info_/ folien/3_dynanimc_programming_.pdf http://algorithms.tutorialhorizon.com/ introduction-to-dynamic-programming-fibonacci-series/ http://algorithms.tutorialhorizon.com/ dynamic-programming-longest-common-substring/ https://www.tu-ilmenau.de/fileadmin/public/iti/lehre/ Eff.Alg/SS/EA-SS-Kapitel5.pdf http://www-i.informatik.rwth-aachen.de/i/fileadmin/ user_upload/documents/dasal/lec_handout.pdf Claudia Gerhold Dynamische Programmierung 9.5.6 4 / 4