module 6 : programmation dynamique. 26/7/2006programmation dynamique2 plan du module de lefficacité...

Module 6 : Programmation dynamique

26/7/2006 Programmation dynamique 2

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


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.



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.


Algorithme de somme minimum1. smin := t[0];2. i := 0;3. WHILE i<n DO BEGIN4. smin := minimum(smin,t[i]);5. j :=i+1;6. WHILE j<n DO BEGIN7. s := t[i];8. k := i+1;9. WHILE k<=j DO BEGIN10. s := s+t[k];11. k := k+112. END;13. smin := minimum(smin,s);14. j := j+115. END;16. i := i+117. END;18. somme_minimale := smin

Complexité proportionnelle à n3



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


Algorithme de somme minimum1. smin := t[0];2. i := 0;3. WHILE i<n DO BEGIN4. s := t[i];5. smin := minimum(smin,s);6. k :=i+1;7. WHILE k<n DO BEGIN8. s := s+t[k];9. smin := minimum(smin,s);10. k := k+111. END;12. i := i+113. END;14. somme_minimale := smin




smin_k valeur minimum de Si,k avec 0≤i≤k smin somme minimum parmi toutes les

sommes Si,h dans le sous-tableaut[0..k-1]

0 n-1k-1 k

t



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])



Il ne reste qu’à mettre à jour smin : smin := min(smin,smin_k)



1. smin := t[0];2. smin_k := t[0];3. k := 1;4. WHILE k<>n DO BEGIN5. smin_k := minimum(smin_k+t[k],t[k]);6. smin := minimum(smin,smin_k);7. k := k+18. END;9. somme_minimale := smin

Complexité proportionnelle à n


Conclusion Un algorithme peut « souvent/parfois »

être amélioré de manière tout à fait notable.


Nombres de Fibonacci F(n) = F(n – 1) + F(n – 2)

pour n > 1 F(0) = 0 F(1) = 1


Nombres de Fibonacci1. FUNCTION fibonacci(n : integer) : longint;

2. BEGIN

3. IF n = 0

4. THEN fibonacci := 0

5. ELSE IF n = 1

6. THEN fibonacci := 1

7. ELSE fibonacci := fibonacci(n-1)+fibonacci(n-2)

8. END;


Nombres de Fibonacci


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 !


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



F0=0

F1=1

FOR i:=2 TO n DO Fi= Fi-1+Fi-2

Complexité proportionnelle à n



1. IF n = 02. THEN fibonacci := 03. ELSE IF n = 14. THEN fibonacci := 15. ELSE BEGIN6. twoback := 0;7. oneback := 1;8. FOR i := 2 TO n DO9. BEGIN10. current := oneback+twoback;11. twoback := oneback;12. oneback := current13. END;14. fibonacci := current15. END


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


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?


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.


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

1

n

jj i

s


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 !


Problème du partitionnement Solution récursive exhaustive:

Soit M[n,k] le coût minimum du partitionnement de s1…sn en k parties

11

1

1

[ , ] min (max( [ , 1], ))

[1, ] 0

[ ,1]

nni j

j i

n

ii

M n k M i k s

M k s k

M n s


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


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

1

[ ]k

ii

p k s

[ ] [ ]

j

kk i

s p j p k


Problème du partitionnement1. { compute prefix sums }2. p[0] := 0;3. FOR i := 1 TO n DO

p[i] := p[i-1] + s[i];

4. { initialize boundary conditions }5. FOR i := 1 TO n DO m[i,1] := p[i];6. FOR i := 1 TO k DO m[1,i] := s[1];7. FOR i := 1 TO n DO 8. FOR j := 1 TO k DO d[i,j] := -1;

9. FOR i := 2 TO n DO10. FOR j := 2 TO k DO11. BEGIN12. m[i,j] := maxint;13. FOR x := 1 TO i-1 DO14. BEGIN15. t := max(m[x,j-1],p[i]-p[x]);16. IF t < m[i,j]17. THEN BEGIN18. m[i,j] := t;19. d[i,j] := x20. END21. END22. END;

Complexité proportionnelle à kn2


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.


Problème du partitionnement1. PROCEDURE reconstructPartition(n,k: integer);2. VAR i : integer;3. BEGIN4. IF k = 15. THEN FOR i := 1 TO n DO write(s[i]:4)6. ELSE BEGIN7. reconstructPartition(d[n,k],k-1);8. write('|');9. FOR i := d[n,k]+1 TO n DO write(s[i]:4)10. END11. END;


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


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



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?



1. La longueur de la plus grande séquence dans s1, s2… sn-1

2. La longueur de la plus grande séquence se terminant avec sn !



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 4Longueur li 1 1 1 2 2 2 1 3 3Prédécesseur - - - 2 2 3 - 6 6



Comment calculer li ?

Longueur de la PLSC:

0

0

1 max

0

i i j ij i

l l pour s s

l

1

maxi nil



Temps de calcul ?

Proportionnel à n2

Peut être amélioré en nlg(n)


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)


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


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 :

1( , ) ( , ) ( 1, ) i k jm i j m i k m k j p p p


Multiplication de matrices Solution récursive :

1( , ) ( 1, )( , )

0i k jm i k m k j p p p i j

m i ji j


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


Multiplication de matrices Pour notre exemple, M aura les valeurs

suivantes :

0 10000 3500

0 0 1000

0 0 01

2Ordre de calcul


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

0 1440 936 1116 1176 1680

0 0 720 1080 1050 1788

0 0 0 600 450 1500

0 0 0 0 150 420

0 0 0 0 0 900

0 0 0 0 0 01

2

3

4

5


Multiplication de matrices1. FOR i := 1 TO n DO m[i,i] := 0;

2. FOR l := 2 TO n DO3. FOR i := 1 TO n-l+1 DO4. BEGIN5. j := i+l-1;6. m[i,j] := maxint;7. FOR k := i TO j-1 DO8. BEGIN9. q := m[i,k]+m[k+1,j] + p[i-1]*p[k]*p[j];10. IF q < m[i,j]11. THEN BEGIN12. m[i,j] := q;13. s[i,j] := k14. END15. END16. END;



Multiplication de matrices Pour afficher le parenthésage optimal, il

suffit d’effectuer un parcours récursif dans la matrice m.


Multiplication de matrices1. PROCEDURE print_matrix_chain_multiply(i,j : integer);2. BEGIN3. IF j > i4. THEN BEGIN5. write('(');6. print_matrix_chain_multiply(i,s[i,j]);7. write('*');8. print_matrix_chain_multiply(s[i,j]+1,j);9. write(')')10. END11. ELSE write(i)12. END;

Appel : print_matrix_chain_multiply(1,n)


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


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.



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



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])


Plus longue sous-suite commune1. FOR i := 0 TO m DO c[i,0] := 0;2. FOR j := 0 TO n DO c[0,j] := 0;3. FOR i := 1 TO m DO4. FOR j := 1 TO n DO5. IF x[i] = y[j]6. THEN BEGIN7. c[i,j] := c[i-1,j-1]+1;8. b[i,j] := upleft9. END10. ELSE IF c[i-1,j] >= c[i,j-1]11. THEN BEGIN12. c[i,j] := c[i-1,j];13. b[i,j] := up14. END15. ELSE BEGIN16. c[i,j] := c[i,j-1];17. b[i,j] := left18. END;19. lcs := c[m,n]

Complexité proportionnelle à m·n



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).



B D C A B A 0 0 0 0 0 0A 0 0U 0U 0U 1\ 1L 1\B 0 1\ 1L 1L 1U 2\ 2LC 0 1U 1U 2\ 2L 2U 2UB 0 1\ 1U 2U 2U 3\ 3LD 0 1U 2\ 2U 2U 3U 3UA 0 1U 2U 2U 3\ 3U 4\B 0 1\ 2U 2U 3U 4\ 4U

début


Plus longue sous-suite commune1. PROCEDURE print_lcs(s : string200; i,j : integer);2. BEGIN3. IF (i<>0) AND (j<>0)4. THEN IF b[i,j] = upleft5. THEN BEGIN6. print_lcs(s,i-1,j-1);7. write(s[i])8. END9. ELSE IF b[i,j] = up THEN print_lcs(s,i-1,j)10. ELSE print_lcs(s,i,j-1)11. END;


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.


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.


Problème 10131Sample Input

6008 13006000 2100500 20001000 40001100 30006000 20008000 14006000 12002000 1900

Sample Output

44597

module 6 : programmation dynamique. 26/7/2006programmation dynamique2 plan du module de lefficacité...

Documents