NSI Lycée Louis de Foix
Correction du problème de rendu de monnaie Première approche
2. Tableau
monnaie\somme 0 1 2 3 4 5 6 7 8 9 10 1 0 1 2 0 0 1 0 0 0 1 0 3 0 0 0 1 0 0 2 1 0 0 2 4 0 0 0 0 1 1 0 1 2 2 1 Total 0 1 2 1 1 2 2 2 2 3 3 3. Algorithme
pour i allant de 0 à n : T[i, 0] ← 0 pour j allant de 1 à s :
res_j ← +∞
pour i allant de 0 à n – 1 : val ← monnaie[i]
si val <= j alors :
res_ij ← 1 + T[n, j – val]
si res_ij < res_j alors : res_j ← res_ij i_opt ← i T[n, j] ← res_j
# enregistrement d’une solution optimale si res_j ≠ +∞ alors :
val ← monnaie[i_opt]
pour i allant de 0 à n – 1 : T[i, j] ← T[i, j – val]
T[i_opt, j] ← T[i_opt, j] + 1
Suite à l’exécution de cet algorithme, le résultat optimal est dans la dernière colonne.
T[n, s] contient le nombre minimal de pièce et T[i, s] pour i allant de 0 à n – 1 le nombre de pièces de chaque type.
4. La complexité en mémoire est donnée par la taille du tableau, donc en O(ns). Ce n’est plus que O(s) si on ne conserve pas les solutions mais seulement le nombre de pièces.
La complexité en temps est toujours en O(ns), puisqu’on a deux boucles imbriquées avec des opérations en temps constant. L’enregistrement d’une solution optimale rajoute des instructions sans changer l’ordre de complexité.
NSI Lycée Louis de Foix Deuxième approche 2. Tableau
monnaie\somme 0 1 2 3 4 5 6 7 8 9 10 0 0 ∞ ∞ ∞ ∞ ∞ ∞ ∞ ∞ ∞ ∞ 1 0 1 2 3 4 5 6 7 8 9 10 3 0 1 2 1 2 3 2 3 4 3 4 4 0 1 2 1 1 2 2 2 2 3 3 3. Algorithme
pour j allant de 1 à s : T[0, j] ← +∞
pour i allant de 0 à n : T[i, 0] ← 0 pour i allant de 1 à n :
pour j allant de 1 à s : val ← monnaie[i-1]
si val > j alors :
T[i, j] ← T[i – 1, j]
sinon :
T[i, j] ← min(T[i – 1, j], 1 + T[i, j – val])
L’algorithme ci-dessus permet de compléter le tableau. T[n, s] contient le nombre minimal de pièces à rendre. Il reste ensuite à reconstituer une solution optimale :
solution ← [0]*n i ← n
j ← s
tant que i > 0 ou j > 0 :
si T[i, j] = T[i – 1, j] alors : i ← i – 1
sinon :
solution[i-1] ← solution[i-1] + 1 j ← j – monnaie[i-1]
Le tableau solution contient alors le nombre de pièces de chaque type.
4. La complexité en mémoire est en O(ns).
La complexité en temps est aussi en O(ns). Reconstituer la solution est en O(n + s) et ne change donc pas l’ordre de complexité global qui reste en O(ns).
