Module 6 : Programmation dynamique

Programmation dynamique Plan du module De l’efficacité d’algorithmes Algorithme de somme minimum Programmation dynamique Nombres de Fibonacci Problème du partitionnement Plus longue séquence croissante Multiplication de matrices Plus longue sous-suite commune Problème 10131 26/7/2006 Programmation dynamique

Algorithme de somme minimum Soit un tableau t[0..n-1] d’entiers de longueur n. Une section de t[0..n-1] est le sous-tableau t[i..j] avec 0 ≤ i≤j <n. Soit Si,j la somme des éléments de la section (i,j). Le problème de la section de somme minimum est le suivant : Soit un tableau t[0..n-1] de longueur n, calculez la valeur Si,j minimum pour le tableau t. 26/7/2006 Programmation dynamique

Algorithme de somme minimum Première approche Concevoir un algorithme qui calcule Si,j pour i et j fixés Utiliser le programme développé au point précédent pour tous les couples (i,j) possibles et conserver la valeur minimum trouvée. 26/7/2006 Programmation dynamique

Algorithme de somme minimum smin := t[0]; i := 0; WHILE i<n DO BEGIN smin := minimum(smin,t[i]); j :=i+1; WHILE j<n DO BEGIN s := t[i]; k := i+1; WHILE k<=j DO BEGIN s := s+t[k]; k := k+1 END; smin := minimum(smin,s); j := j+1 i := i+1 somme_minimale := smin Complexité proportionnelle à n3 26/7/2006 Programmation dynamique

Algorithme de somme minimum Pour une valeur m donnée, la boucle sur j calcule les sommes Sm,m, Sm,m+1,… Sm,n-1. Chaque somme Sm,h est calculée par la boucle (sur k) la plus interne en ignorant qu’à l’étape précédente, on a calculé Sm,h-1 26/7/2006 Programmation dynamique

Algorithme de somme minimum smin := t[0]; i := 0; WHILE i<n DO BEGIN s := t[i]; smin := minimum(smin,s); k :=i+1; WHILE k<n DO BEGIN s := s+t[k]; k := k+1 END; i := i+1 somme_minimale := smin Complexité proportionnelle à n2 26/7/2006 Programmation dynamique

Algorithme de somme minimum k-1 k n-1 t smin_k valeur minimum de Si,k avec 0≤i≤k smin somme minimum parmi toutes les sommes Si,h dans le sous-tableau t[0..k-1] 26/7/2006 Programmation dynamique

Algorithme de somme minimum Le fait d’examiner l’élément k introduit un nouvel ensemble de sections : toutes les sections de bornes [i..k] avec 0≤i≤k. smin_k := min(smin_k+t[k],t[k]) 26/7/2006 Programmation dynamique

Algorithme de somme minimum Il ne reste qu’à mettre à jour smin : smin := min(smin,smin_k) 26/7/2006 Programmation dynamique

Algorithme de somme minimum smin := t[0]; smin_k := t[0]; k := 1; WHILE k<>n DO BEGIN smin_k := minimum(smin_k+t[k],t[k]); smin := minimum(smin,smin_k); k := k+1 END; somme_minimale := smin Complexité proportionnelle à n 26/7/2006 Programmation dynamique

Programmation dynamique Conclusion Un algorithme peut « souvent/parfois » être amélioré de manière tout à fait notable. 26/7/2006 Programmation dynamique

Programmation dynamique Nombres de Fibonacci F(n) = F(n – 1) + F(n – 2) pour n > 1 F(0) = 0 F(1) = 1 26/7/2006 Programmation dynamique

Programmation dynamique Nombres de Fibonacci FUNCTION fibonacci(n : integer) : longint; BEGIN IF n = 0 THEN fibonacci := 0 ELSE IF n = 1 THEN fibonacci := 1 ELSE fibonacci := fibonacci(n-1)+fibonacci(n-2) END; 26/7/2006 Programmation dynamique

Programmation dynamique Nombres de Fibonacci 26/7/2006 Programmation dynamique

Programmation dynamique Nombres de Fibonacci Cette façon de faire est très peu intéressante car les mêmes valeurs sont recalculées sans cesse On peut montrer que pour calculer F(n) le nombre d’appels de fonctions dépasse 1.6n Complexité exponentielle ! 26/7/2006 Programmation dynamique

Programmation dynamique Nombres de Fibonacci Amélioration : On peut calculer F(n) en un temps linéaire en mémorisant des valeurs déjà calculées et nécessaires aux calculs suivants On perd de l’espace mémoire, mais on gagne du temps 26/7/2006 Programmation dynamique

Programmation dynamique Nombres de Fibonacci F0=0 F1=1 FOR i:=2 TO n DO Fi= Fi-1+Fi-2 Complexité proportionnelle à n 26/7/2006 Programmation dynamique

Programmation dynamique Nombres de Fibonacci IF n = 0 THEN fibonacci := 0 ELSE IF n = 1 THEN fibonacci := 1 ELSE BEGIN twoback := 0; oneback := 1; FOR i := 2 TO n DO BEGIN current := oneback+twoback; twoback := oneback; oneback := current END; fibonacci := current END 26/7/2006 Programmation dynamique

Programmation dynamique La programmation dynamique est une technique dans laquelle on mémorise des résultats déjà obtenus et qu’on réutilise pour trouver de nouveaux résultats, généralement sur des récurrences 26/7/2006 Programmation dynamique

Problème du partitionnement Exemple : On a neuf livres qui ont respectivement 100, 200, 300…900 pages. Trois personnes doivent scanner ces livres. Comment effectuer la répartition de manière à ce que chacun des trois ait à peu près le même nombre de pages à traiter? 26/7/2006 Programmation dynamique

Problème du partitionnement Soit un arrangement S de nombres non-négatifs s1…sn et un entier k. Le but est de partitionner S en k parties de manière à minimiser la somme des valeurs de chacune des k parties. 26/7/2006 Programmation dynamique

Problème du partitionnement Il s’agit de placer k-1 séparateurs pour obtenir les k parties. Où placer le dernier séparateur ? Entre le ième et le (i+1)ème élément de S Quel est le coût de cette opération? Le maximum entre le coût de la dernière partie le coût de la plus grande partie à gauche de i 26/7/2006 Programmation dynamique

Problème du partitionnement Quel est le coût de la plus grande partie à gauche de i ? Il suffit de placer les k-2 séparateurs restants optimalement sur la partie s1…si On est en présence du problème de départ mais sur une instance plus petite Solution récursive ! 26/7/2006 Programmation dynamique

Problème du partitionnement Solution récursive exhaustive: Soit M[n,k] le coût minimum du partitionnement de s1…sn en k parties 26/7/2006 Programmation dynamique

Problème du partitionnement Désavantage : temps de calcul exponentiel puisqu’on recalcule tout le temps les mêmes valeurs Solution: Stocker les valeurs déjà calculées Nécessite un tableau de k fois n éléments 26/7/2006 Programmation dynamique

Problème du partitionnement Optimisation: Pour accélérer les calculs, on se donne un tableau d’aide p[1..n] avec et : ce qui permet de calculer plus rapidement la récurrence 26/7/2006 Programmation dynamique

Problème du partitionnement { compute prefix sums } p[0] := 0; FOR i := 1 TO n DO p[i] := p[i-1] + s[i]; { initialize boundary conditions } FOR i := 1 TO n DO m[i,1] := p[i]; FOR i := 1 TO k DO m[1,i] := s[1]; FOR i := 1 TO n DO FOR j := 1 TO k DO d[i,j] := -1; FOR i := 2 TO n DO FOR j := 2 TO k DO BEGIN m[i,j] := maxint; FOR x := 1 TO i-1 DO t := max(m[x,j-1],p[i]-p[x]); IF t < m[i,j] THEN BEGIN m[i,j] := t; d[i,j] := x END END; Complexité proportionnelle à kn2 26/7/2006 Programmation dynamique

Problème du partitionnement En fait l’algorithme nécessite une deuxième matrice qui mémorise l’endroit où les séparateurs sont placés. Le chemin se construit à l’envers à l’aide d’une procédure récursive. 26/7/2006 Programmation dynamique

Problème du partitionnement PROCEDURE reconstructPartition(n,k: integer); VAR i : integer; BEGIN IF k = 1 THEN FOR i := 1 TO n DO write(s[i]:4) ELSE BEGIN reconstructPartition(d[n,k],k-1); write('|'); FOR i := d[n,k]+1 TO n DO write(s[i]:4) END END; 26/7/2006 Programmation dynamique

Problème du partitionnement Voici le résultat du problème de départ 100 200 300 400 500 600 700 800 900 100 100 100 ---- -1 -1 -1 300 200 200 ---- -1 1 1 600 300 300 ---- -1 2 2 1000 600 400 ---- -1 3 3 1500 900 600 ---- -1 3 4 2100 1100 900 ---- -1 4 5 2800 1500 1100 ---- -1 5 6 3600 2100 1500 ---- -1 5 6 4500 2400 1700 ---- -1 6 7 100 200 300 400 500| 600 700| 800 900 M D 26/7/2006 Programmation dynamique

Plus longue séquence croissante But : trouver une plus longue séquence croissante dans une séquence de n nombres. Attention : les éléments sélectionnés ne doivent pas nécessairement être consécutifs! Exemple : 9 5 2 8 7 3 1 6 4 PLSC : 3 2 3 4 ou 2 3 6 26/7/2006 Programmation dynamique

Plus longue séquence croissante Que faut-il connaître sur les n-1 premiers élements de la séquence pour pouvoir donner la réponse pour l’entièreté de la séquence des n éléments? 26/7/2006 Programmation dynamique

Plus longue séquence croissante La longueur de la plus grande séquence dans s1, s2… sn-1 La longueur de la plus grande séquence se terminant avec sn ! 26/7/2006 Programmation dynamique

Plus longue séquence croissante Soit li la longueur de la plus longue séquence se terminant avec le ième caractère Séquence 9 5 2 8 7 3 1 6 4 Longueur li Prédécesseur - 26/7/2006 Programmation dynamique

Plus longue séquence croissante Comment calculer li ? Longueur de la PLSC: 26/7/2006 Programmation dynamique

Plus longue séquence croissante Temps de calcul ? Proportionnel à n2 Peut être amélioré en nlg(n) 26/7/2006 Programmation dynamique

Multiplication de matrices On cherche à effectuer un produit de matrices de réels M1 x M2 x … Mn Mi comporte pi-1 lignes et pi colonnes Le nombre de multiplications réelles doit être minimal (la multiplication de 2 matrices se fait de manière usuelle) 26/7/2006 Programmation dynamique

Multiplication de matrices Exemple : M1(50x10) M2(10x20) M3(20x5) Comme la multiplication matricielle est associative, il faut trouver la façon optimale d’effectuer les multiplications (M1M2)M3 50·0·20 + 50·20·5 = 15000 M1(M2M3) 10·20·5 + 50·10·5 = 3500 26/7/2006 Programmation dynamique

Multiplication de matrices Soit m(i, j) le nombre minimal de multiplications réelles nécessaires au calcul de Mi x Mi+1 x … Mj Soit (Mi … Mk) x (Mk+1 … Mj) un parenthésage optimal, alors : 26/7/2006 Programmation dynamique

Multiplication de matrices Solution récursive : 26/7/2006 Programmation dynamique

Multiplication de matrices La solution qui consiste à explorer toutes les possibilités est à rejeter car cela donne un algorithme de complexité exponentielle. Mieux : stocker les valeurs m[i,j] au fur et à mesure dans un tableau bi-dimensionnel, en fait une matrice triangulaire supérieure 26/7/2006 Programmation dynamique

Multiplication de matrices Pour notre exemple, M aura les valeurs suivantes : 0 10000 3500 0 0 1000 0 0 0 2 Ordre de calcul 1 26/7/2006 Programmation dynamique

Multiplication de matrices Pour les matrices M1…M6 de dimensions respectives 6, 12, 20, 3, 10, 5, 18 Solution : ((1*(2*3))*((4*5)*6)) 1440 936 1116 1176 1680 720 1080 1050 1788 600 450 1500 150 420 900 5 4 3 2 1 26/7/2006 Programmation dynamique

Multiplication de matrices FOR i := 1 TO n DO m[i,i] := 0; FOR l := 2 TO n DO FOR i := 1 TO n-l+1 DO BEGIN j := i+l-1; m[i,j] := maxint; FOR k := i TO j-1 DO q := m[i,k]+m[k+1,j] + p[i-1]*p[k]*p[j]; IF q < m[i,j] THEN BEGIN m[i,j] := q; s[i,j] := k END END; Complexité proportionnelle à n3 26/7/2006 Programmation dynamique

Multiplication de matrices Pour afficher le parenthésage optimal, il suffit d’effectuer un parcours récursif dans la matrice m. 26/7/2006 Programmation dynamique

Multiplication de matrices PROCEDURE print_matrix_chain_multiply(i,j : integer); BEGIN IF j > i THEN BEGIN write('('); print_matrix_chain_multiply(i,s[i,j]); write('*'); print_matrix_chain_multiply(s[i,j]+1,j); write(')') END ELSE write(i) END; Appel : print_matrix_chain_multiply(1,n) 26/7/2006 Programmation dynamique

Plus longue sous-suite commune Une sous-suite d’une suite est la suite en question dont éventuellement certains éléments sont manquants. Exemple : BCDB est une sous-suite de la suite ABCBDAB Soit deux suites X et Y. On appelle sous-suite commune une suite qui est sous-suite de X et de Y Exemple : X = ABCBDAB Y=BDCABA BCA est une sous-suite commune à X et Y alors que BCBA et BDAB sont deux sous-suites les plus longues communes à X et à Y 26/7/2006 Programmation dynamique

Plus longue sous-suite commune Calculer la PLSSC de deux suites par la force brute n’est pas praticable dû au nombre exponentiel de possibilités. 26/7/2006 Programmation dynamique

Plus longue sous-suite commune Soit Xi = x1x2…xi le ième préfixe de X=x1x2..xm Soit c[i,j] la longueur de la PLSSC de Xi et Y j. Si xi ≠ yj alors la PLSSC ne peut inclure à la fois xi et yj. Donc elle doit être soit une PLSSC de x1x2…xi-1 et y1y2…yj une PLSSC de x1x2…xi et y1y2…yj-1 26/7/2006 Programmation dynamique

Plus longue sous-suite commune Si i ou j vaut 0, alors c[i,j] = 0. Si xi = yj et i,j >0, alors c[i,j] = c[i-1,j-1]+1 Si xi ≠ yj et i,j >0, alors C[i,j] = max(c[i,j-1], c[i-1,j]) 26/7/2006 Programmation dynamique

Plus longue sous-suite commune FOR i := 0 TO m DO c[i,0] := 0; FOR j := 0 TO n DO c[0,j] := 0; FOR i := 1 TO m DO FOR j := 1 TO n DO IF x[i] = y[j] THEN BEGIN c[i,j] := c[i-1,j-1]+1; b[i,j] := upleft END ELSE IF c[i-1,j] >= c[i,j-1] c[i,j] := c[i-1,j]; b[i,j] := up ELSE BEGIN c[i,j] := c[i,j-1]; b[i,j] := left END; lcs := c[m,n] Complexité proportionnelle à m·n 26/7/2006 Programmation dynamique

Plus longue sous-suite commune L’affichage du résultat (la sous-suite commune) se fait à l’aide d’un parcours récursif dans le tableau d’aide B à deux entrées (pour X et pour Y) rempli des valeurs (left, up, upleft). 26/7/2006 Programmation dynamique

Plus longue sous-suite commune B D C A B A 0 0 0 0 0 0 A 0 0U 0U 0U 1\ 1L 1\ B 0 1\ 1L 1L 1U 2\ 2L C 0 1U 1U 2\ 2L 2U 2U B 0 1\ 1U 2U 2U 3\ 3L D 0 1U 2\ 2U 2U 3U 3U A 0 1U 2U 2U 3\ 3U 4\ B 0 1\ 2U 2U 3U 4\ 4U début 26/7/2006 Programmation dynamique

Plus longue sous-suite commune PROCEDURE print_lcs(s : string200; i,j : integer); BEGIN IF (i<>0) AND (j<>0) THEN IF b[i,j] = upleft THEN BEGIN print_lcs(s,i-1,j-1); write(s[i]) END ELSE IF b[i,j] = up THEN print_lcs(s,i-1,j) ELSE print_lcs(s,i,j-1) END; 26/7/2006 Programmation dynamique

Programmation dynamique Problème 10131 Some people think that the bigger an elephant is, the smarter it is. To disprove this, you want to take the data on a collection of elephants and put as large a subset of this data as possible into a sequence so that the weights are increasing, but the IQ's are decreasing. The input will consist of data for a bunch of elephants, one elephant per line, terminated by the end-of-file. The data for a particular elephant will consist of a pair of integers: the first representing its size in kilograms and the second representing its IQ in hundredths of IQ points. Both integers are between 1 and 10000. The data will contain information for at most 1000 elephants. Two elephants may have the same weight, the same IQ, or even the same weight and IQ. 26/7/2006 Programmation dynamique

Programmation dynamique Problème 10131 Say that the numbers on the i-th data line are W[i] and S[i]. Your program should output a sequence of lines of data; the first line should contain a number n; the remaining n lines should each contain a single positive integer (each one representing an elephant). If these n integers are a[1], a[2],..., a[n] then it must be the case that W[a[1]] < W[a[2]] < ... < W[a[n]] and S[a[1]] > S[a[2]] > ... > S[a[n]] In order for the answer to be correct, n should be as large as possible. All inequalities are strict: weights must be strictly increasing, and IQs must be strictly decreasing. There may be many correct outputs for a given input, your program only needs to find one. 26/7/2006 Programmation dynamique

Programmation dynamique Problème 10131 Sample Input 6008 1300 6000 2100 500 2000 1000 4000 1100 3000 6000 2000 8000 1400 6000 1200 2000 1900 Sample Output 4 5 9 7 26/7/2006 Programmation dynamique