Module 6 : Programmation dynamique

Présentation au sujet: "Module 6 : Programmation dynamique"— Transcription de la présentation:

1 Module 6 : Programmation dynamique

2 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

3 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

4 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

5 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

6 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

7 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

8 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

9 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

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

11 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

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

13 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

14 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

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

16 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

17 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

18 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

19 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

20 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

21 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

22 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

23 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

24 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

25 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

26 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

27 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

28 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

29 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

30 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

31 Problème du partitionnement
Voici le résultat du problème de départ | | M D 26/7/2006 Programmation dynamique

32 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 : PLSC : ou 2 3 6 26/7/2006 Programmation dynamique

33 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

34 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

35 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

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

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

38 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

39 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·5 = 15000 M1(M2M3) 10·20·5 + 50·10·5 = 3500 26/7/2006 Programmation dynamique

40 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

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

42 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

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

44 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

45 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

46 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

47 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

48 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

49 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

50 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

51 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

52 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

53 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

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

55 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

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

57 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

58 Programmation dynamique
Problème 10131 Sample Input Sample Output 4 5 9 7 26/7/2006 Programmation dynamique