Explorer les Livres électroniques
Catégories
Explorer les Livres audio
Catégories
Explorer les Magazines
Catégories
Explorer les Documents
Catégories
1. Principe général
Idée de base :
Eviter de calculer deux fois la même chose, normalement en utilisant une table de résultats
déjà calculés, remplie au fur et à mesure qu'on résout les sous problèmes.
Remarques
C'est une méthode ascendante : On commence d'habitude par les sous problèmes les plus
petits et on remonte vers les sous problèmes de plus en plus difficiles.
La programmation dynamique est souvent employée pour résoudre des problèmes
d'optimisation satisfaisant le principe d'optimalité: "Dans une séquence optimale (de décisions
ou de choix), chaque sousséquence doit aussi être optimale". Un exemple de ce type de
problème est le plus court chemin entre deux sommets d’un graphe.
2. Applications
Exemple 1: Calcul de Cnp
Il existe une décomposition connue pour le calcul de Cnp :
Cnp = Cn1p1 + Cn1p
C00 = Cn0 = Cnn = 1
Fonction C_rec (n,p)
Si (n=p) ou (p=0): retourner(1)
Sinon retourner(C_rec(n1,p1) + C_rec(n1,p))
Fsi
Mais cette décomposition va générer un nombre important de sous problèmes identiques. Par
exemple pour calculer C85 l’arbre des appels récursifs est :
Support de cours – MCP4 : Programmation Dynamique 1/7
C85
C74 C75
C63 C64 C64 C65
C52 C53 C53 C54 C53 C54 C54 C55
... ....... ........ ........
On remarque qu’il existe beaucoup de sous exemplaires qui se répètent. Ceci influence
négativement la complexité de l’algorithme qui est en (Cnp).
b) On peut aussi faire le calcul par programmation dynamique.(triangle de Pascal)
0 1 2 3 4
0 1
1 1 1
2 1 2 1 (remplissage de la table)
3 1 3 3 1
4 1 4 6 4 1
Le calcul se fait ligne par ligne et de gauche à droite, cad que les sous exemplaires les plus
simples sont calculés en premiers et les résultats, que l’on sauvegarde dans la table, servent à
calculer les exemplaires plus grands.
Fonction C_Dyn (n,p)
var
Mat[0..n,0..p]
Pour i=0,n :
Pour j=0,Min(i,p) :
Si i=j ou j=0 :
Mat[i,j] := 1
Sinon
Mat[i,j] := Mat[i1,j1] + Mat[i,j]
Fsi
Fp
Fp
retourner(Mat[n,p])
Cet algorithme est en O(np).
Exemple 2: La suite de fibonacci
La définition de cette suite est donnée par la décomposition :
f0 = 1 , f1 = 1 et
fn = fn1 + fn2 pour n > 1
Support de cours – MCP4 : Programmation Dynamique 2/7
L’approche descendante (Diviser pour Résoudre) donne l’algorithme suivant:
Fib_Rec(n:Entier) : Entier;
Si n<=1 : Fib_Rec := 1
Sinon Fib_Rec := Fib_Rec(n1) + Fib_Rec(n2)
Fsi
Comme dans l’exemple précédent, cet algorithme a un coût exponentiel car l’arbre des appels
récursifs généré contient beaucoup d’appels identiques.
L’approche par Programmation Dynamique suggère de commencer par les sousproblèmes les
plus petits (Fib(0) et Fib(1)) est de calculer les sousproblèmes plus complexes (Fib(2), Fib(3),
Fib(4), ... Fib(n)) en gardant la trace des résultats intermédiaires nécessaires au calcul.
Dans ce problème, les résultats intermédiaires nécessaires au calcul d’un sousproblème
donné (Fib(i)) sont les deux sousproblèmes précédents (Fib(i1) et Fib(i2) car Fib(i)=Fib(i1) +
Fib(i2)), d’où l’algorithme suivant:
FibDyn(n:Entier) : Entier;
var
i,j,k : Entier;
j := 0; i := 1;
Pour k=1,n :
j := i+j;
i := ji
Fp;
Fib_Dyn := j
Cet algorithme est en o(n).
Exemple 3: Série mondiale
A et B disputent une série de matchs (au maximum 2n1).
L'équipe gagnante est celle qui remporte n victoires.
La probabilité que A remporte une victoire, lors d’un match, est : q1
La probabilité que B remporte une victoire est : q2 = 1q1
Il n’y a pas de match nul.
On définit P(i, j) comme la probabilité que A remporte la série, sachant qu'elle doit encore
gagner ‘i’ victoires alors qu’il reste ‘j’ victoires à B pour gagner.
On a ainsi :
P(0, j) = 1 ( A a déjà gagné la série et j > 0)
P(i, 0) = 0 ( A a déjà perdu la série et i > 0)
P(0, 0) indéfini
P(i, j) = q1*P(i1, j) + q2*P(i, j1) i, j > 0
Support de cours – MCP4 : Programmation Dynamique 3/7
Algorithme récursif :
P(i, j) :
Si i = 0 et j > 0 :
P := 1
Sinon
Si i > 0 et j = 0 :
P := 0
Sinon
Si i > 0 et j > 0 :
P := q1*P(i1,j) + q2*P(i, j1)
Fsi
Fsi
Fsi
T(k) = temps d’exécution de P(i, j) avec k = i+j
Equation de récurrence : T(k) = 2T(k1) + b
Solution : T(k) = C12k + C2
donc T(k) est en O(2k) ou encore en O(2i+j)
P(n, n) prend un temps dans l’ordre de O(4n) (car 22n = 4n)
Programmation dynamique
Utilisation d'une table remplie diagonale par diagonale:
0 1 2 3 4
0 1 1 1 1 1
1 0 1/2 3/4 7/8 15/16
2 0 1/4 1/2 11/16 13/16
3 0 1/8 5/16 1/2 21/32
4 0 1/16 3/16 11/32 1/2
L’algorithme pour remplir la table jusqu’à la position P[i,j] :
Pour S = 1, i+j
P[0, S] := 1
P[S, 0] := 0
Pour k=1, S1
P[k, Sk] := q1P[k1, Sk] + q2P[k, Sk1]
Finpour
Finpour
Le temps d’exécution est en O(n2) pour le calcul de P(n,n).
Support de cours – MCP4 : Programmation Dynamique 4/7
Exemple 4: Les plus courts chemins
Il s’agit de trouver les plus courts chemins entre chaque pair de sommets d’un graphe valué
(Algorithme de Floyd).
C’est un problème d’optimisation qui vérifie le principe d’optimalité : Si le plus courts chemin
(chemin optimal) entre deux sommets A et B passe par un sommet intermédiaire C, alors les
portions du chemin entre A et C et entre C et B doivent forcément être optimales.
Dans un graphe formé par n sommets, l’algorithme consiste à calculer les plus courts chemins
entre chaque pair de sommets en utilisant comme sommets intermédiaires, dans l’ordre et de
façon successives les sommets 1, 2, 3 .. n.
A l’état initial aucun sommet intermédiaire n’est utilisé, les plus courts chemins sont donnés
directement par la matrice des poids des arcs D0[1..n,1..n]. D0[i,j]=+∞ désignera l’inexistence
d’un arc entre les sommets i et j.
A l’étape 1 les nouveaux chemins sont calculés par :
D1[i,j] = Min (D0[i,j] , D0[i,1] + D0[1,j])
A l’étape k les nouveaux chemins sont calculés en prenant en considération tous les sommets
entre 1 et k :
Dk[i,j] = Min (Dk1[i,j] , Dk1[i,k] + Dk1[k,j])
Après l’étape n, la matrice Dn contiendra les longueurs des plus courts chemins entre chaque
couple de sommets (i,j).
Exemple 5: Multiplication chaînée de matrices
Sachant que la multiplication de matrices est associative :
M1(M2 M3) = (M1 M2) M3
et sachant que pour multiplier une matrice de p lignes et q colonnes M1(p,q) par une autre
matrice de q lignes et r colonnes M2(q,r) il faut p*q*r multiplications élémentaires, le
problème est de trouver le nombre minimal de multiplications élémentaires nécessaire pour
multiplier une série de n matrices : M1 M2 M3 ... Mn . Appelant ce nombre m(1,n).
Supposons que les dimensions des matrices M soient stockées dans un vecteur D[0..n] de sorte
que les dimensions d’une matrice Mi soient données par D[i1] (nb de lignes) et D[i] (nb de
colonnes).
Support de cours – MCP4 : Programmation Dynamique 5/7
On pourra alors écrire que m(i,i+1) = D[i1]*D[i]*D[i+1]. C’est le nombre de multiplications
élémentaires nécessaire au produit : Mi Mi+1
C’est un problème d’optimisation vérifiant le principe d’optimalité:
« Si pour faire le produit de n matrices avec un nombre minimal d’opérations élémentaires on
découpe le produit des n matrices en deux sousproduits au niveau de la iième matrice :
(M1 * M2 * ... Mi) * (Mi+1 * Mi+2 * ... Mn)
alors chacun des deux sousproduits doit aussi être optimal :
Le sousproduit P1 : (M1 * M2 * ... Mi) doit être calculé de façon optimal (soit m(1,i) opération
élémentaires), le résultat est une matrice X de dimensions : D[0] x D[i].
Le sousproduit P2 : (Mi+1 * Mi+2 * ... Mn) doit aussi être calculé de façon optimal (soit m(i+1,n)
opérations élémentaires), le résultat est une matrice Y de dimensions : D[i] x D[n].
Le produit final : X * Y nécessitera alors D[0]*D[i]*D[n] multiplications élémentaires. »
Donc si on découpe le produit initial au niveau de la iième matrice, on pourra écrire :
m(1,n) = m(1,i) + m(i+1,n) + D[0]*D[i]*D[n]
En procédant par décomposition récursive pour calculer m(1,n) les sousproduits P1 et P2 on
aboutira à un algorithme récursif (du type Diviser pour Résoudre) très inefficace à cause du
nombre élevé de sous problèmes identiques générés par la décomposition.
L’algorithme récursif est :
fonction m(i,j:entier) : entier;
var
k, x : entier;
Si i=j : retourner(0)
Sinon
x := +
Pour k:=i , j1:
x := min { x , D[i1]*D[k]*D[j] + m(i,k) + m(k+1,j) }
Fp
Retourner(x)
Fsi
cad :
m(1,1)+m(2,n)+D[0]*D[1]*D[n] pour: M1(M2 M3...Mn)
m(1,2)+m(3,n)+D[0]*D[2]*D[n] pour: (M1 M2)(M3...Mn)
...
m(1,n)=Min m(1,k)+m(k+1,n)+D[0]*D[k]*D[n] pour: (M1...Mk)(Mk+1...Mn)
...
m(1,n1)+m(n,n)+D[0]*D[n1]*D[n] pour: (M1 M2...Mn1)Mn
Support de cours – MCP4 : Programmation Dynamique 6/7
En appliquant la programmation dynamique on procédera de façon ascendante pour éviter de
calculer plusieurs fois le même sousproblème, en sauvegardant les résultats calculés dans
une table m[1..n,1..n] qu’on remplit au fur et à mesure qu’on progresse dans la résolution.
Le remplissage de la table se fera en diagonal à l’aide de l’algorithme suivant :
Pour i:=1,n /* la 1ere diagonale */
m[i,i] = 0 /* car il n’y a pas de produit de matrice */
Fp;
Pour i:=1,n1 /* la 2e diagonale */
m[i,i+1] = D[i1]*D[i]*D[i+1] /* Pour le produit : Mi * Mi+1 */
Fp;
Pour s:=2,n1 /* les autres diagonales */
Pour i:=1,ns
m(i,i+s) = min { m(i,k) + m(k+1,i+s) + D[i1]*D[k]*D[i+s] }
i≤ k ≤ i+s1
Fp
Fp
Retourner( m[1,n] )
m[1,n]
diagonale 2
diagonale 1
Support de cours – MCP4 : Programmation Dynamique 7/7