Dynamische Programmierung

Transkript

1 Dynamische Programmierung Claudia Gerhold Claudia Gerhold Dynamische Programmierung / 4

2 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 / 4

3 Einführung Claudia Gerhold Dynamische Programmierung / 4

4 Beispiel Fibonacci Zahlen,,,, 3, 5, 8, 3,,... Fib() = Fib() = Fib(i) = Fib(i ) + Fib(i ), i > Claudia Gerhold Dynamische Programmierung / 4

5 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 / 4

6 Teilergebnisse mehrfach berechnen Fib(5) Fib(4) Fib(3) Fib(3) Fib() Fib() Fib() Fib() Fib() Fib() Fib() Fib() Fib() Fib() Fib() Quelle: vgl. fib.png Claudia Gerhold Dynamische Programmierung / 4

7 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 / 4

8 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 / 4

9 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 / 4

10 Dynamische Programmierung Claudia Gerhold Dynamische Programmierung / 4

11 Historie Richard Ernest Bellman, Mathematiker *9.8.9 (Brooklyn) (Los Angeles) Paper: u.a. Theory of Dynamic Programming (954) Lösen von Optimierungsproblemen Memoization: Merken berechneter Werte Reduzierung des Rechenaufwands Quelle: wiki/richard E. Bellman#/media/ File:Richard Ernest Bellman.jpg Claudia Gerhold Dynamische Programmierung / 4

12 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 / 4

13 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 / 4

14 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 / 4

15 Neuer Aufrufbaum Fib(5) Fib(4) Fib(3) Fib(3) Fib() Fib() Fib() Fib() Fib() Quelle: vgl. fib.png Claudia Gerhold Dynamische Programmierung / 4

16 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 / 4

17 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 / 4

18 Anwendungsbeispiele für Dynamische Programmierung Claudia Gerhold Dynamische Programmierung / 4

19 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 / 4

20 Beispiel X = < A, B, C, B, D, A, B > Y = < B, D, C, A, B, A > X Claudia Gerhold Dynamische Programmierung / 4

21 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 / 4

22 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 / 4

23 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 / 4

24 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 / 4

25 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 / 4

26 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 / 4

27 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 / 4

28 Arbeitsweise j 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 / 4

29 Arbeitsweise j 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 / 4

30 Arbeitsweise j 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 / 4

31 Arbeitsweise j 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 / 4

32 Arbeitsweise j 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 / 4

33 Arbeitsweise j 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 / 4

34 Arbeitsweise j 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 / 4

35 Arbeitsweise j i B D C A B A A B 3 C 4 B D A 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 / 4

36 Arbeitsweise j i B D C A B A A B 3 C 4 B D A 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 BCBA Claudia Gerhold Dynamische Programmierung / 4

37 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 / 4

38 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 / 4

39 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 / 4

40 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 / 4

41 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 / 4

42 Arbeitsweise i j M a t r a t z e 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 / 4

43 Arbeitsweise i j M a t r a t z e 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 / 4

44 Arbeitsweise i j M a t r a t z e K 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 / 4

45 Arbeitsweise i j M a t r a t z e 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 = a, s = M, a M d[][] = min(,, ) + = Claudia Gerhold Dynamische Programmierung / 4

46 Arbeitsweise i j M a t r a t z e K 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 / 4

47 Arbeitsweise i j M a t r a t z e K a t z e 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 / 4

48 Rekonstruktion eines minimalen Editskripts i j M a t r a t z e K a t z e 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 / 4

49 Gewichtete Levenshtein-Distanz Unterschiedliche Gewichtung der Operationen Zur Vermeidung bestimmter Operation Claudia Gerhold Dynamische Programmierung / 4

50 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 / 4

51 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 / 4

52 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 / 4

53 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 / 4

54 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 / 4

55 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 / 4

56 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 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 / 4

57 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 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 / 4

58 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 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 / 4

59 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 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] = = 7 Claudia Gerhold Dynamische Programmierung / 4

60 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 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] = = 7 kein weiteres k Claudia Gerhold Dynamische Programmierung / 4

61 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 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] = = 936 Claudia Gerhold Dynamische Programmierung / 4

62 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 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] = = 8 Claudia Gerhold Dynamische Programmierung / 4

63 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 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] = = 8 kein weiteres k min(936, 8) Claudia Gerhold Dynamische Programmierung / 4

64 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 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 / 4

65 Rekonstruktion optimaler Klammerung i j 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 / 4

66 Rekonstruktion optimaler Klammerung i j 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 / 4

67 Rekonstruktion optimaler Klammerung i j 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 / 4

68 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 / 4

69 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 / 4

70 Vielen Dank für eure Aufmerksamkeit! Gibt es Fragen? Claudia Gerhold Dynamische Programmierung / 4

71 Quellen T. Cormen et al., Introduction To Algorithms, MIT Press, 9 SS/HalloWelt/DP_.pdf SS5/HalloWelt/dyn_programming.beamer.pdf folien/3_dynanimc_programming_.pdf introduction-to-dynamic-programming-fibonacci-series/ dynamic-programming-longest-common-substring/ Eff.Alg/SS/EA-SS-Kapitel5.pdf user_upload/documents/dasal/lec_handout.pdf Claudia Gerhold Dynamische Programmierung / 4