$course$/QCM de NSI/Terminale/Programmation dynamique Sous-problèmes qui se chevauchent, sous-structure optimale,
mémoïsation descendante, tabulation ascendante,
exemples classiques (suite de Fibonacci, plus longue
sous-séquence commune, sac à dos, distance d'édition,
rendu de monnaie).

]]> Programmation dynamique — Q01 : Idée centrale de la programmation dynamique Quel est le principe fondamental de la
programmation dynamique ?

]]> Le terme « programmation » dans « programmation
dynamique » vient de l'optimisation linéaire
(Bellman, années $1950$), et non de la
programmation informatique. Il signifie « plan,
tableau », ce qui justifie la notion de
tabulation.

]]> 1.0 0.0 0 true true abc Diviser le problème en deux moitiés et résoudre chacune indépendamment

]]> Cette description correspond au paradigme
« diviser pour régner ». La différence
essentielle est que les sous-problèmes y sont
disjoints, alors qu'en programmation
dynamique ils se recouvrent.

]]> Faire à chaque étape le choix qui semble localement le meilleur

]]> Cette description correspond au principe des
algorithmes gloutons. La programmation
dynamique, au contraire, explore toutes les
possibilités de manière organisée, en
mémorisant les solutions des sous-problèmes.

]]> Modifier le programme à mesure qu'il s'exécute

]]> Cette description évoque l'auto-modification
de code, qui n'a aucun rapport avec la
programmation dynamique. Le mot
« dynamique » désigne ici le caractère
temporel de la décision, pas une
modification du programme.

]]> Mémoriser les solutions des sous-problèmes

]]> La programmation dynamique exploite la
présence de sous-problèmes qui se répètent
dans la décomposition récursive. En les
mémorisant, on évite la croissance
exponentielle du nombre de recalculs.

]]> Programmation dynamique — Q02 : Mémoïsation Qu'est-ce que la mémoïsation ?

]]> Le mot « mémoïsation » associe les idées de
mémoire et de récursivité. C'est l'approche
« descendante » de la programmation dynamique :
on part du problème complet, on descend dans les
sous-problèmes en mémorisant les résultats au
passage.

]]> 1.0 0.0 0 true true abc La comparaison de deux algorithmes pour choisir le plus rapide

]]> Cette opération relève de la mesure de
performance, et n'a aucun rapport avec la
mémoïsation.

]]> La conversion automatique d'une fonction récursive en boucle itérative

]]> Cette transformation s'appelle la
dérécursivation, et c'est une technique
différente. La mémoïsation conserve la
structure récursive de la fonction, en y
ajoutant simplement un cache.

]]> La compression d'un programme en mémoire pour gagner de la place

]]> La mémoïsation n'a aucun rapport avec la
taille du programme. Elle concerne le
temps de calcul, en évitant de
recalculer plusieurs fois la même valeur.

]]> Stocker les résultats déjà calculés dans un cache

]]> À chaque appel récursif, l'algorithme
vérifie si le résultat est déjà connu
(typiquement dans un dictionnaire ou un
tableau) avant de le calculer. Si la valeur
est déjà disponible, elle est renvoyée
directement.

]]> Programmation dynamique — Q03 : Tabulation Qu'appelle-t-on tabulation en programmation
dynamique ?

]]> La mémoïsation et la tabulation sont les deux
faces de la programmation dynamique : la
mémoïsation est descendante (récursive, avec un
cache) ; la tabulation est ascendante
(itérative, avec un tableau). En pratique, la
tabulation est souvent plus rapide, car elle
évite le surcoût des appels récursifs.

]]> 1.0 0.0 0 true true abc Le découpage d'un problème en sous-problèmes égaux

]]> Cette description correspond au paradigme
« diviser pour régner ». La tabulation
consiste à remplir un tableau ; elle ne
découpe pas le problème.

]]> La création d'une table HTML pour afficher les résultats

]]> La « tabulation » dans ce contexte
algorithmique n'a aucun rapport avec une
mise en forme HTML. Il s'agit du
remplissage progressif d'un tableau de
valeurs.

]]> Une optimisation des comparaisons utilisée dans un algorithme de tri

]]> La tabulation est spécifique à la
programmation dynamique. Elle n'a pas de
rôle particulier dans les algorithmes de
tri.

]]> Remplir un tableau des petits aux grands sous-problèmes

]]> C'est l'approche dite « ascendante » : on
part des cas de base et on remplit
progressivement un tableau, sans aucune
récursion.

]]> Programmation dynamique — Q04 : Suite de Fibonacci en programmation dynamique Quelle est la complexité de la suite de Fibonacci
calculée avec mémoïsation ?

]]> Le passage de $O(2^n)$ à $O(n)$ pour la suite
de Fibonacci est l'exemple canonique de la
puissance de la programmation dynamique. Pour
$n = 50$, on passe ainsi de plus d'un million
d'appels à seulement $51$.

]]> 1.0 0.0 0 true true abc $O(n^2)$

]]> La programmation dynamique appliquée à
Fibonacci ne nécessite qu'un parcours
linéaire des valeurs, et non une double
itération qui justifierait une complexité
quadratique.

]]> $O(\log n)$

]]> Avec la récurrence $f(n) = f(n-1) + f(n-2)$,
la mémoïsation calcule une fois chaque
valeur de $f(0)$ à $f(n)$ : le nombre de
calculs est proportionnel à $n$, et non à
$\log n$.

]]> $O(2^n)$

]]> Cette complexité correspond à la version
récursive naïve, sans mémoïsation. Le
recours à un cache réduit drastiquement ce
coût.

]]> $O(n)$

]]> Avec mémoïsation, chaque valeur
$\text{fib}(k)$ pour $k$ allant de $0$ à
$n$ n'est calculée qu'une seule fois, ce
qui donne $n$ calculs au total.

]]> Programmation dynamique — Q05 : Sous-problèmes qui se chevauchent Que signifie « le problème a des sous-problèmes
qui se chevauchent » ?

]]> Cette propriété est essentielle pour que la
programmation dynamique soit utile. Si les
sous-problèmes sont uniques, la mémoïsation
n'apporte rien et on retombe sur le paradigme
« diviser pour régner » classique.

]]> 1.0 0.0 0 true true abc Les sous-problèmes ont tous la même solution

]]> Les sous-problèmes peuvent avoir des
solutions très différentes, ce qui est
d'ailleurs le cas le plus courant. Le
chevauchement signifie qu'ils
apparaissent plusieurs fois dans
l'arbre des appels récursifs, et non qu'ils
partagent leur solution.

]]> Les sous-problèmes sont triés par taille décroissante

]]> L'ordre dans lequel on considère les
sous-problèmes n'a rien à voir avec leur
chevauchement. Le mot « chevauchement »
renvoie à la notion de doublon, pas
d'ordre.

]]> Les sous-problèmes sont indépendants les uns des autres

]]> Si les sous-problèmes étaient indépendants,
on appliquerait plutôt le paradigme
« diviser pour régner ». La programmation
dynamique exploite précisément le contraire.

]]> Plusieurs sous-problèmes apparaissent plusieurs fois

]]> C'est le cas typique de la suite de
Fibonacci, où la valeur $\text{fib}(k)$ est
calculée plusieurs fois dans la version
naïve. La programmation dynamique évite
précisément ces recalculs.

]]> Programmation dynamique — Q06 : Sous-structure optimale Que signifie « le problème possède une
sous-structure optimale » ?

]]> La sous-structure optimale et le caractère
chevauchement des sous-problèmes sont les deux
ingrédients qui rendent un problème adapté à la
programmation dynamique. Sans la première, on
ne peut pas combiner les solutions ; sans la
seconde, la mémoïsation ne sert à rien.

]]> 1.0 0.0 0 true true abc La taille des sous-problèmes diminue de manière logarithmique

]]> Cette description évoque la diminution
logarithmique du paradigme « diviser pour
régner » équilibré, mais elle ne correspond
pas à la définition de la sous-structure
optimale.

]]> L'optimum global se compose des optima des sous-problèmes

]]> Cette propriété permet de construire la
solution optimale en combinant les solutions
optimales des sous-problèmes. C'est elle qui
rend la programmation dynamique applicable.

]]> Le problème peut être résolu en parallèle sur plusieurs processeurs

]]> La sous-structure optimale est une propriété
mathématique du problème, et non une
caractéristique algorithmique. Le
parallélisme relève de l'implémentation.

]]> Les sous-problèmes ont tous strictement la même taille

]]> Cette uniformité de taille n'est pas
requise. La sous-structure optimale parle de
la composition des solutions, pas des
tailles des sous-problèmes.

]]> Programmation dynamique — Q07 : Programmation dynamique et algorithme glouton Quelle est la différence principale entre un
algorithme glouton et un algorithme de
programmation dynamique ?

]]> Quand un problème possède la propriété de choix glouton (un choix local mène à
l'optimum global), un algorithme glouton suffit
et reste plus efficace. Sinon, la programmation
dynamique est souvent nécessaire pour
atteindre l'optimum.

]]> 1.0 0.0 0 true true abc Le glouton choisit localement, la PD explore les sous-problèmes

]]> L'algorithme glouton est plus rapide mais
peut manquer l'optimum global. La
programmation dynamique est plus coûteuse,
mais elle garantit l'optimum global lorsque
le problème possède la sous-structure
optimale.

]]> L'algorithme glouton est récursif, alors que la programmation dynamique est itérative

]]> Les deux approches peuvent être implémentées
aussi bien récursivement qu'itérativement.
C'est le principe qui les distingue, et
non leur forme syntaxique.

]]> La programmation dynamique est utilisée uniquement pour les jeux vidéo

]]> La programmation dynamique a un champ
d'application très large : alignement de
séquences, optimisation économique,
traitement automatique du langage, et bien
d'autres domaines.

]]> L'algorithme glouton ne fonctionne que sur les graphes

]]> Les algorithmes gloutons s'appliquent à de
très nombreux types de problèmes : rendu de
monnaie, planification d'activités, sac à
dos fractionnaire, et bien d'autres.

]]> Programmation dynamique — Q08 : Structure de mémoïsation Quelle structure Python convient le mieux pour
mémoïser une fonction prenant un seul paramètre
entier positif ?

]]> Pour des paramètres entiers, la liste est
idéale. Pour des paramètres plus complexes
(chaînes, $p$-uplets), le dictionnaire
devient nécessaire.

]]> 1.0 0.0 0 true true abc Une liste indexée par la valeur du paramètre

]]> Pour des paramètres entiers positifs dans
une plage connue, une liste donne un accès
en $O(1)$ très efficace. C'est la structure
la plus rapide.

]]> Un fichier sur le disque

]]> Le disque est beaucoup trop lent pour de la
mémoïsation en mémoire. Il s'utiliserait
plutôt pour persister un cache entre deux
exécutions du programme.

]]> Un dictionnaire avec les paramètres comme clés

]]> Un dictionnaire fonctionne, mais avec un
surcoût lié au calcul des empreintes. Pour
des indices entiers, la liste reste plus
rapide.

]]> Une variable globale unique

]]> Une seule variable ne peut stocker qu'une
seule valeur, alors que la mémoïsation
demande d'en mémoriser plusieurs.

]]> Programmation dynamique — Q09 : Origine du terme Le terme « programmation dynamique » a été
introduit en $1953$ par :

]]> Bellman a expliqué qu'il avait choisi le terme
« dynamique » pour évoquer le caractère
temporel de la décision, et « programmation »
au sens de planification. L'équation de Bellman
reste aujourd'hui un outil central en
optimisation et en apprentissage par
renforcement.

]]> 1.0 0.0 0 true true abc Tim Berners-Lee

]]> Tim Berners-Lee est l'inventeur du World
Wide Web. Son travail n'a aucun rapport
avec la programmation dynamique.

]]> Alan Turing

]]> Alan Turing est principalement connu pour
la machine de Turing et le décryptage
d'Enigma, mais pas pour la programmation
dynamique.

]]> Donald Knuth

]]> Donald Knuth est connu pour son traité
monumental « The Art of Computer
Programming », mais ce n'est pas lui qui
est à l'origine de la programmation
dynamique.

]]> Richard Bellman

]]> Richard Bellman a inventé la programmation
dynamique pour traiter des problèmes
d'optimisation séquentielle. Le mot
« programmation » vient du jargon militaire
de l'époque, dans le sens de
« planification ».

]]> Programmation dynamique — Q10 : Exemple classique de programmation dynamique Lequel des problèmes suivants se résout
typiquement par programmation dynamique ?

]]> Autres exemples typiques : sac à dos,
alignement de séquences (plus longue
sous-séquence commune, distance
d'édition). Tous ont en commun la
sous-structure optimale et les
sous-problèmes qui se chevauchent.

]]> 1.0 0.0 0 true true abc Tester si un nombre est premier

]]> Les tests de primalité ne se prêtent pas à
la programmation dynamique, car ils ne font
pas apparaître naturellement de
sous-problèmes qui se chevauchent.

]]> Inverser une chaîne de caractères

]]> C'est une opération en $O(n)$ qui ne
requiert aucune mémoïsation. Aucune
décomposition en sous-problèmes ne
s'impose.

]]> Trier un très grand tableau

]]> Les algorithmes de tri usuels (tri par
insertion, par sélection, par fusion) ne
relèvent pas de la programmation
dynamique.

]]> Rendre la monnaie avec le moins de pièces

]]> Le nombre minimal de pièces pour une
somme $s$ se déduit des sommes plus
petites $s - p$, pour chaque pièce $p$.
Ces sous-problèmes se chevauchent : on
mémorise leurs résultats dans un
tableau pour ne les calculer qu'une
fois.

]]> Programmation dynamique — Q11 : Mémoïsation manuelle de Fibonacci On écrit la fonction suivante :

memo = {}
def fib(n):
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fib(n - 1) + fib(n - 2)
    return memo[n]

Combien d'appels effectifs (qui calculent
réellement, sans utiliser le cache) sont
effectués pour fib(10) ?

]]> La mémoïsation transforme la complexité
$O(2^n)$ en $O(n)$ : c'est un gain
algorithmique considérable. Le code reste
pourtant très proche de la version récursive
naïve.

]]> 1.0 0.0 0 true true abc Exactement un

]]> Il faut bien calculer chaque valeur
intermédiaire au moins une fois. La
mémoïsation évite les recalculs, pas les
calculs initiaux.

]]> Environ onze

]]> Avec le cache, chaque fib(n) n'est calculée
qu'une fois pour $n \geq 2$ (les cas de base
fib(0) et fib(1) ne sont pas mémoïsés),
soit une douzaine d'appels effectifs. Les
appels sur une valeur déjà calculée sont
satisfaits immédiatement par memo, ce qui
évite l'explosion exponentielle.

]]> Plus de mille

]]> Cet ordre de grandeur correspond à la
version sans mémoïsation. Avec un cache,
le nombre de calculs est bien plus
modeste.

]]> Environ cent

]]> C'est trop. Le nombre de valeurs distinctes
à calculer est seulement $n + 1$, soit
$11$, et non $n^2$.

]]> Programmation dynamique — Q12 : Tabulation pour Fibonacci Quelle est la version itérative ascendante de
la suite de Fibonacci ?

]]> L'approche itérative ascendante évite la récursion et le
cache. Pour Fibonacci, on peut même optimiser
l'espace en ne gardant que les deux dernières
valeurs : a, b = b, a + b.

]]> 1.0 0.0 0 true true abc def fib(n): return round((1.618 ** n) / 2.236)]]> Cette formule est celle de Binet, qui
utilise le nombre d'or. Elle ne relève pas
de la programmation dynamique et devient
imprécise pour de grandes valeurs de $n$ à
cause des arrondis sur les flottants.

]]> def fib(n): t = [0, 1] for i in range(2, n + 1): t.append(t[i-1] + t[i-2]) return t[n]]]> On remplit un tableau t de taille $n + 1$
en partant des cas de base ($t[0] = 0$ et
$t[1] = 1$), puis on construit les valeurs
suivantes par récurrence. La complexité
est $O(n)$ en temps comme en espace.

]]> def fib(n): if n <= 1: return n return fib(n-1) + fib(n-2)]]> Il s'agit de la version récursive naïve,
sans mémoïsation ni tabulation. Sa
complexité est $O(2^n)$.

]]> def fib(n, memo={}): if n in memo: return memo[n] if n <= 1: return n memo[n] = fib(n-1, memo) + fib(n-2, memo) return memo[n]]]> Il s'agit bien de programmation dynamique,
mais descendante : la fonction reste
récursive, part de $n$ et mémoïse les
résultats en redescendant vers les cas de
base. La version ascendante remplit un
tableau des cas de base vers $n$, sans
aucune récursion.

]]> Programmation dynamique — Q13 : Problème du sac à dos Le problème du sac à dos $0/1$ consiste à
choisir un sous-ensemble d'objets à mettre dans
un sac de capacité fixée pour maximiser leur
valeur totale. Quelle est sa complexité en
programmation dynamique avec un sac de
capacité $W$ et $n$ objets ?

]]> Le tableau compte une case par objet et
par capacité de $0$ à $W$ : son
remplissage demande donc de l'ordre de
$n \times W$ opérations, bien moins que
les $2^n$ sous-ensembles d'une recherche
exhaustive tant que $W$ reste
raisonnable.

]]> 1.0 0.0 0 true true abc $O(n!)$

]]> Aucune raison particulière n'amène à une
complexité factorielle pour ce problème.

]]> $O(n)$

]]> Il faut considérer chaque objet pour chaque
capacité possible du sac. La complexité
dépend nécessairement des deux paramètres.

]]> $O(2^n)$

]]> Cette complexité correspond à l'approche
par recherche exhaustive (essayer tous les
sous-ensembles d'objets). La programmation
dynamique est bien plus rapide.

]]> $O(n \cdot W)$

]]> On remplit un tableau à deux dimensions de
taille $n \times W$. Pour chaque case, le
calcul est en $O(1)$. La complexité totale
est donc $O(nW)$.

]]> Programmation dynamique — Q14 : Sac à dos : comparer les deux approches Pour le problème du sac à dos $0/1$,
l'algorithme glouton qui prend les objets par
ordre décroissant du ratio « valeur / poids »
donne-t-il toujours la solution optimale ?

]]> Le sac à dos $0/1$ ne possède pas la
propriété de choix glouton. Il faut donc
explorer plusieurs possibilités, ce que fait la
programmation dynamique en $O(nW)$, à comparer
aux $O(2^n)$ de la recherche exhaustive.

]]> 1.0 0.0 0 true true abc L'algorithme glouton est plus rapide mais moins précis

]]> Il s'agit ici d'optimum exact, pas
d'approximation. Soit l'algorithme garantit
l'optimum, soit il ne le garantit pas. Il
n'y a pas de notion de précision
intermédiaire.

]]> Non, le glouton peut manquer l'optimum en $0/1$

]]> Pour le sac à dos $0/1$, l'algorithme
glouton peut être trompé. Avec un sac de
capacité $50$ et les objets
$\{(60, 10), (100, 20), (120, 30)\}$
(valeur, poids), le glouton prend d'abord
$(60, 10)$ puis $(100, 20)$ (ratios $6$ puis
$5$), pour une valeur de $160$. Or l'optimum
est $(100, 20) + (120, 30)$, de poids $50$ et
de valeur $220$.

]]> Oui, c'est l'algorithme correct pour ce problème

]]> Cette approche gloutonne est optimale pour
le sac à dos fractionnaire (où l'on
peut couper un objet), mais pas pour la
version $0/1$, où chaque objet est pris
entièrement ou pas du tout.

]]> Cela dépend du langage de programmation utilisé

]]> La propriété est purement mathématique. Elle
ne dépend pas du langage choisi pour
l'implémentation.

]]> Programmation dynamique — Q15 : Approche descendante et approche ascendante Quelle est la différence entre l'approche
descendante et l'approche ascendante en
programmation dynamique ?

]]> L'approche descendante (mémoïsation) est plus
naturelle quand la définition du problème est
récursive. L'approche ascendante (tabulation)
est en général plus économe en mémoire et plus
rapide en pratique. Le choix dépend du
contexte.

]]> 1.0 0.0 0 true true abc La descendante est récursive, l'ascendante itérative

]]> L'approche descendante part du problème
global et descend dans les sous-problèmes,
en utilisant un cache. L'approche
ascendante part des cas de base et
construit progressivement la table des
résultats jusqu'au problème global.

]]> L'approche descendante concerne les graphes, l'approche ascendante concerne les listes

]]> Les deux approches s'appliquent à toutes
les structures de données. La distinction
n'a rien à voir avec le type des éléments
manipulés.

]]> L'approche descendante est toujours plus rapide

]]> En pratique, l'approche ascendante est
souvent plus rapide, car elle évite le
surcoût des appels récursifs. La complexité
asymptotique est cependant la même dans les
deux cas.

]]> Aucune, ces termes sont synonymes

]]> Ce sont deux approches distinctes, même si
elles permettent toutes deux de résoudre
les mêmes problèmes.

]]> Programmation dynamique — Q16 : Deux variables au lieu d'un tableau Voici deux calculs ascendants du terme de rang $n$ de la suite de
Fibonacci :

def fib_tableau(n):
    f = [0 for k in range(n + 1)]
    if n > 0:
        f[1] = 1
    for k in range(2, n + 1):
        f[k] = f[k - 1] + f[k - 2]
    return f[n]

def fib_deux(n):
    a = 0
    b = 1
    for k in range(n):
        c = a + b
        a = b
        b = c
    return a

Pour un grand $n$, que peut-on dire de la mémoire utilisée par ces
deux fonctions ?

]]> Une programmation dynamique ascendante n'a pas toujours besoin de
garder tout son tableau : quand chaque valeur ne dépend que d'un
petit nombre de valeurs calculées juste avant, on peut ne conserver que
celles-ci. Le temps reste le même, la mémoire devient constante.

]]> 1.0 0.0 0 true true abc Toutes deux utilisent une mémoire proportionnelle à $n$, chacune faisant $n$ tours

]]> Tu confonds temps et mémoire : les deux fonctions font bien de
l'ordre de $n$ tours de boucle, mais fib_deux réutilise à chaque
tour les mêmes trois variables au lieu de remplir un tableau.

]]> Toutes deux utilisent une mémoire constante, aucune n'étant récursive

]]> Tu ne regardes que la pile d'appels : fib_tableau n'est pas
récursive, mais elle construit une liste de $n + 1$ cases, ce qui
occupe une mémoire proportionnelle à $n$.

]]> Proportionnelle à $n$ pour fib_tableau, constante pour fib_deux

]]> Exactement : chaque terme ne dépend que des deux termes qui le
devancent. fib_deux ne garde que ces deux valeurs et un intermédiaire,
alors que fib_tableau conserve tous les termes calculés.

]]> fib_deux utilise plus de mémoire, avec trois variables contre une

]]> Tu comptes les noms au lieu des valeurs stockées : la seule
variable f de fib_tableau désigne une liste de $n + 1$
nombres, bien plus que les trois nombres de fib_deux.

]]> Programmation dynamique — Q17 : Rendu de monnaie en programmation dynamique Pour le rendu de monnaie avec un système de
pièces arbitraire, la programmation dynamique
calcule, en $O(n \cdot s)$ (où $s$ est la somme
à rendre et $n$ le nombre de pièces) :

]]> Le rendu de monnaie est l'exemple emblématique
d'un problème où l'algorithme glouton échoue
sur certains systèmes monétaires (par exemple
$\{1, 3, 4\}$), alors que la programmation
dynamique garantit l'optimum.

]]> 1.0 0.0 0 true true abc La somme totale rendue

]]> La somme à rendre est donnée en entrée du
problème, elle n'est pas calculée par
l'algorithme.

]]> Le nombre minimal de pièces pour la somme

]]> Pour chaque sous-somme $k \in [0, s]$,
l'algorithme calcule le nombre minimal de
pièces nécessaires. La récurrence utilisée
est
$\text{ND}(k) = 1 + \min_{p}\, \text{ND}(k - p)$,
où $p$ parcourt les pièces disponibles.

]]> La pièce la plus grande utilisée

]]> Cette description correspond plutôt à
l'approche gloutonne, qui choisit toujours
la plus grande pièce disponible.

]]> Une séquence ordonnée de pièces

]]> La programmation dynamique calcule un
nombre minimal, et non une séquence
ordonnée. La séquence des pièces
effectivement utilisées peut être
reconstruite ensuite, par un parcours à
rebours du tableau.

]]> Programmation dynamique — Q18 : Programmation dynamique et diviser pour régner En quoi la programmation dynamique se
distingue-t-elle du paradigme « diviser pour
régner » classique ?

]]> Pour identifier si un problème relève de la
programmation dynamique, on peut tracer
l'arbre des appels récursifs et chercher les
nœuds dupliqués. S'il y en a beaucoup, la
programmation dynamique est probablement le
bon outil.

]]> 1.0 0.0 0 true true abc Le paradigme « diviser pour régner » utilise toujours la récursivité, contrairement à la programmation dynamique

]]> Les deux paradigmes peuvent utiliser la
récursivité. La programmation dynamique
peut aussi être itérative (par tabulation),
mais ce n'est pas la différence
essentielle.

]]> La programmation dynamique ne s'applique qu'aux problèmes portant sur des entiers

]]> La programmation dynamique s'applique à
tout problème possédant les deux propriétés
requises (sous-structure optimale et
sous-problèmes qui se chevauchent), quel que soit
le type des données manipulées.

]]> La programmation dynamique est plus simple à coder

]]> C'est subjectif et souvent l'inverse. Les
algorithmes de type « diviser pour régner »
sont en général plus simples à concevoir.

]]> En PD les sous-problèmes se recouvrent, pas en diviser-pour-régner

]]> C'est la distinction fondamentale. Sans
recouvrement, la mémoïsation n'apporte
rien. Avec recouvrement, elle apporte des
gains majeurs.

]]> Programmation dynamique — Q19 : Compromis mémoire et temps La programmation dynamique illustre un
compromis classique en algorithmique. Lequel ?

]]> Pour la suite de Fibonacci, la version naïve a
une complexité en $O(2^n)$ en temps avec
$O(n)$ d'espace de pile. La version mémoïsée
passe à $O(n)$ en temps avec $O(n)$ de mémoire :
on a légèrement augmenté l'espace, mais on a
divisé le temps par un facteur exponentiel.

]]> 1.0 0.0 0 true true abc Moins de mémoire consommée et moins de temps de calcul

]]> Il n'y a pas de gain gratuit. Ne stocker
aucune valeur intermédiaire reviendrait au
cas naïf récursif, qui est précisément
beaucoup plus lent.

]]> Plus de mémoire, beaucoup moins de temps

]]> On stocke les solutions intermédiaires
(mémoire en plus) pour ne plus avoir à les
recalculer (temps en moins). C'est un
compromis central en algorithmique.

]]> Aucun changement par rapport à l'algorithme naïf

]]> La programmation dynamique apporte un gain
majeur sur de nombreux problèmes (suite de
Fibonacci, sac à dos, plus longue
sous-séquence commune, etc.).

]]> Plus de temps de calcul mais moins de mémoire consommée

]]> C'est exactement l'inverse. La
programmation dynamique consomme plus de
mémoire, mais elle accélère
considérablement le calcul.

]]> Programmation dynamique — Q20 : Lecture d'une programmation dynamique ascendante Que calcule la fonction Python suivante ?

def f(n):
    T = [0] * (n + 1)
    T[0] = 1
    for i in range(1, n + 1):
        T[i] = T[i-1] * i
    return T[n]
]]> Cet exemple illustre une programmation dynamique ascendante très simple : on
remplit un tableau en partant du cas de base.
C'est l'archétype de la tabulation pour une
récurrence simple.

]]> 1.0 0.0 0 true true abc La factorielle $n!$

]]> On a $T[i] = T[i-1] \cdot i = i!$, en
partant de $T[0] = 1 = 0!$. La fonction
renvoie donc bien $n!$, par construction
ascendante.

]]> La $n$-ième valeur de la suite de Fibonacci

]]> La suite de Fibonacci utiliserait
l'instruction T[i] = T[i-1] + T[i-2],
fondée sur une addition de deux termes
précédents, et non sur la multiplication
par $i$.

]]> $2^n$

]]> Pour obtenir $2^n$, il faudrait écrire
T[i] = T[i-1] 2 plutôt que
T[i-1] i.

]]> La somme $1 + 2 + \cdots + n$

]]> Une somme s'obtiendrait par addition. Or
la fonction effectue une multiplication
(T[i-1] * i), qui correspond à un
produit cumulé.

]]> Programmation dynamique — Q22 : Découper une barre au meilleur prix Un menuisier vend des morceaux de barre : prix[m] est le prix,
en euros, d'un morceau de longueur m. La fonction suivante
calcule le meilleur prix d'une barre de longueur n que l'on peut
couper en morceaux :

def meilleur_prix(n, prix):
    t = [0 for k in range(n + 1)]
    for k in range(1, n + 1):
        meilleur = 0
        for m in range(1, k + 1):
            if prix[m] + t[k - m] > meilleur:
                meilleur = prix[m] + t[k - m]
        t[k] = meilleur
    return t[n]

Que renvoie meilleur_prix(4, [0, 1, 5, 8, 9]) ?

]]> La case t[k] contient le meilleur prix d'une barre de longueur
k. On la calcule en essayant chaque longueur m du premier
morceau, le reste valant t[k - m], déjà calculé. Chaque
sous-problème n'est résolu qu'une fois.

]]> 1.0 0.0 0 true true abc $4$ euros

]]> Erreur : $4$ euros correspond à quatre morceaux de longueur $1$.
La boucle interne essaie aussi des premiers morceaux de longueur
$2$, $3$ ou $4$, bien plus rentables.

]]> $8$ euros

]]> Erreur : $8$ est la valeur de t[3], le meilleur prix d'une
barre de longueur $3$. La fonction renvoie t[4], calculé au
dernier tour de la boucle externe.

]]> $9$ euros

]]> Erreur : $9$ euros, c'est la barre vendue d'un seul tenant, ou
coupée en $3 + 1$. Pour k = 4, la fonction essaie aussi
prix[2] + t[2], qui vaut $5 + 5 = 10$.

]]> $10$ euros

]]> Bonne réponse : le tableau se remplit en [0, 1, 5, 8, 10].
Pour k = 4, les candidats valent $1 + 8$, $5 + 5$, $8 + 1$ et
$9 + 0$ : le meilleur est $10$, avec deux morceaux de longueur
$2$.

]]> Programmation dynamique — Q23 : Reconstruire la solution En programmation dynamique, on calcule souvent
une valeur optimale (par exemple le coût
minimal). Comment retrouve-t-on la solution effective, c'est-à-dire la séquence de
décisions qui mène à cet optimum ?

]]> Cette technique de reconstruction à rebours
est universelle en programmation dynamique :
après avoir rempli la table, on retrace les
choix faits à chaque étape pour reconstruire
la solution complète.

]]> 1.0 0.0 0 true true abc On ne peut pas, la programmation dynamique ne donne que la valeur optimale

]]> La solution effective peut tout à fait
être reconstruite : c'est ce qui rend la
programmation dynamique utile dans les
applications réelles.

]]> On lance plusieurs programmations dynamiques avec différents paramètres pour identifier les choix

]]> Cette approche serait inefficace. Une seule
exécution suffit, à condition de bien lire
la table à rebours.

]]> On la reconstruit en parcourant la table à rebours, à partir de la valeur finale

]]> On remonte dans la table en suivant les
choix qui ont mené à chaque valeur
optimale. Cela permet de retrouver la
séquence de décisions sans alourdir le
calcul lui-même.

]]> On stocke aussi la solution dans la table

]]> C'est possible mais coûteux en mémoire, et
souvent inutile : la solution se
reconstruit toujours en $O(n)$ après le
calcul, par un parcours à rebours.

]]> Programmation dynamique — Q25 : Reconnaître un problème de programmation dynamique Pour qu'un problème se résolve efficacement par
programmation dynamique, il doit posséder :

]]> Ces deux propriétés sont l'identité de la
programmation dynamique. Sans la sous-structure
optimale, il est impossible de combiner les
solutions. Sans le recouvrement des
sous-problèmes, la mémoïsation est inutile, et
l'on retombe sur le paradigme « diviser pour
régner » classique.

]]> 1.0 0.0 0 true true abc Une décomposition logarithmique du problème

]]> Cette caractéristique correspond plutôt au
paradigme « diviser pour régner »
classique. Ce n'est pas un prérequis de la
programmation dynamique.

]]> Un seul cas de base et une seule récurrence

]]> Le nombre de cas de base ou de récurrences
n'est pas un critère. Ce sont les
propriétés structurelles du problème qui
comptent.

]]> Une fonction objectif uniquement de minimisation

]]> La programmation dynamique s'applique aussi
à des problèmes de maximisation (sac à dos,
plus longue sous-séquence) ou de comptage
(nombre de chemins).

]]> Sous-structure optimale et sous-problèmes répétés

]]> Ces deux propriétés sont nécessaires. La
sous-structure optimale permet de combiner
les solutions, et les sous-problèmes qui
se chevauchent rendent la mémoïsation
utile.

]]> Programmation dynamique — Q26 : Chemins dans une grille On veut compter le nombre de chemins
monotones (n'allant qu'à droite ou en bas)
d'un coin d'une grille rectangulaire de $m$
lignes et $n$ colonnes au coin opposé. Quelle
est la récurrence appropriée et la complexité
par programmation dynamique ?

]]> Ce problème est l'un des plus simples
illustrant la programmation dynamique sur une
table à deux dimensions. La même technique
s'étend aux variantes (cases bloquées,
sommes minimales, etc.).

]]> 1.0 0.0 0 true true abc $C(i, j) = C(i-1, j) + C(i, j-1)$,
complexité $O(m \cdot n)$

]]> Bonne réponse : pour atteindre la case
$(i, j)$, on vient soit du dessus
$(i-1, j)$ soit de la gauche $(i, j-1)$.
Les cas de base sont les bords, où il
n'existe qu'un seul chemin (descente ou
déplacement à droite uniquement), d'où
$C(0, j) = C(i, 0) = 1$. On
remplit un tableau à deux dimensions de
taille $m \times n$, chaque case en
$O(1)$, donc complexité totale
$O(m \cdot n)$.

]]> $C(i, j) = C(i-1, j-1) + 1$, complexité
$O(m \cdot n)$

]]> Erreur : la récurrence proposée ne
correspond pas au problème. On ne peut se
déplacer qu'à droite ou vers le bas,
pas en diagonale. La récurrence correcte
additionne les chemins venant de la case
du dessus et de la case de gauche.

]]> $C(i, j) = C(i-1, j) \cdot C(i, j-1)$,
complexité $O(m + n)$

]]> Erreur : pour compter le nombre de
chemins, on additionne les
possibilités, on ne les multiplie pas. La
complexité est aussi sous-estimée :
remplir un tableau à deux dimensions
coûte $O(m \cdot n)$, pas $O(m + n)$.

]]> $C(i, j) = i + j$, calcul direct en
$O(1)$ sans tableau

]]> Erreur : le nombre de chemins n'est pas la
somme des coordonnées mais bien le
coefficient binomial $\binom{i+j}{i}$. Une
formule fermée existe, mais elle se
calcule en $O(\min(i, j))$ multiplications,
pas en temps constant.

]]> Programmation dynamique — Q28 : Trace sur le rendu de monnaie Avec les pièces $\{1, 3, 4\}$ et la somme à
rendre $s = 6$, quel est le nombre minimal
de pièces calculé par programmation dynamique
(et l'écart avec la méthode gloutonne qui
prend toujours la plus grosse pièce
possible) ?

]]> Cet exemple est emblématique : il prouve
qu'avec un système monétaire arbitraire,
l'algorithme glouton n'est plus optimal. Avec
les systèmes monétaires usuels (euros,
dollars), l'algorithme glouton fonctionne
grâce à des propriétés structurelles
particulières des dénominations choisies.

]]> 1.0 0.0 0 true true abc La programmation dynamique trouve $1$
pièce(s), l'algorithme glouton en utilise $2$

]]> Erreur : aucune pièce de valeur $6$ n'existe dans le système monétaire $\{1, 3, 4\}$, donc une pièce ne peut pas suffire. Le minimum atteignable est de
$2$ pièces (combinaison $3 + 3$).

]]> La programmation dynamique et l'algorithme
glouton trouvent tous deux $3$ pièces

]]> Erreur : si c'était le cas, la
programmation dynamique n'aurait aucun
intérêt sur ce problème. Refaire le
calcul : avec $3 + 3$, $2$ pièces
suffisent, ce que l'algorithme glouton
rate.

]]> Aucune des deux méthodes n'aboutit, car
aucune combinaison de ces pièces ne donne $6$

]]> Erreur : la combinaison $3 + 3 = 6$ est
parfaitement valide. De même
$1 + 1 + 4 = 6$ ou $1 + 1 + 1 + 3 = 6$
fonctionnent. Le problème est résoluble.

]]> La programmation dynamique trouve $2$
pièces, l'algorithme glouton en utilise $3$

]]> Bonne réponse : c'est l'exemple
pédagogique classique où la stratégie
gloutonne échoue à atteindre l'optimum.
Glouton : prendre $4$, reste $2$, prendre $1$, prendre $1$, total $3$ pièces
(combinaison $4 + 1 + 1$).
Programmation dynamique : explore toutes
les combinaisons et trouve $3 + 3 = 6$,
soit seulement $2$ pièces. Cas
paradigmatique de l'intérêt de la
programmation dynamique.

]]> Programmation dynamique — Q29 : Trace du sac à dos On dispose d'un sac de capacité $W = 5$ et de
trois objets : $O_1$ (poids $2$, valeur $3$),
$O_2$ (poids $3$, valeur $4$), $O_3$ (poids
$4$, valeur $5$). Quelle est la valeur
optimale obtenue par programmation
dynamique ?

]]> Construire le tableau $V$ à la main est un
excellent exercice. Il révèle que la
programmation dynamique « teste » toutes les
combinaisons utiles sans en énumérer
explicitement aucune. Pour reconstruire la
solution (les objets choisis), on remonte
dans le tableau à rebours en regardant
pour chaque case quelle décision a mené à
l'optimum.

]]> 1.0 0.0 0 true true abc $12$ (en prenant les trois objets)

]]> Erreur : prendre les trois objets pèse
$2 + 3 + 4 = 9 \mathrm{kg}$, bien
au-delà de la capacité du sac. C'est la
difficulté du sac à dos : on doit
renoncer à des objets précieux à cause
de la contrainte de poids.

]]> $7$ (en prenant $O_1$ et $O_2$)

]]> Bonne réponse : on construit la table
$V[i][w]$ donnant la valeur optimale en
considérant les $i$ premiers objets pour
une capacité $w$. Quelques valeurs clés :
$V[2][5] = \max(V[1][5], V[1][2] + 4) = \max(3, 3 + 4) = 7$. À l'arrivée $V[3][5] = \max(V[2][5], V[2][1] + 5) = \max(7, 0 + 5) = 7$. La solution optimale prend $O_1$ ($2 \mathrm{kg}$, $3$) et $O_2$ ($3 \mathrm{kg}$, $4$), poids total $5$, valeur totale $7$.

]]> $5$ (en prenant uniquement $O_3$)

]]> Erreur : prendre seulement $O_3$ ne donne
que $5$ de valeur, alors que la combinaison $O_1 + O_2$ donne $7$ pour un poids identique au sac (capacité atteinte exactement). Il vaut donc mieux
combiner plusieurs objets.

]]> $9$ (en prenant $O_2$ et $O_3$)

]]> Erreur : la combinaison $O_2$ + $O_3$ pèse $3 + 4 = 7 \mathrm{kg}$, ce qui dépasse la capacité $W = 5$ du sac. Cette solution n'est donc pas réalisable.

]]> Programmation dynamique — Q30 : Code du sac à dos en programmation dynamique Quel code Python implémente correctement la
programmation dynamique ascendante (par
tabulation) pour le sac à dos $0/1$ avec $n$
objets de poids poids[i] et valeurs
valeurs[i] et un sac de capacité W ?

]]> Complexité : $O(n \cdot W)$ en temps et en
espace. Optimisation possible : ne conserver
que deux lignes du tableau, celle que l'on
remplit et celle du dessus, ce qui ramène
l'espace à $O(W)$. Pour
reconstruire la solution effective, on
remonte le tableau de la case $V[n][W]$ vers
la case $V[0][0]$, en notant à chaque
étape si l'objet $i$ a été pris.

]]> 1.0 0.0 0 true true abc def sac_a_dos(poids, valeurs, W): total = 0 for i in range(len(poids)): total += valeurs[i] return total]]> Erreur : ce code retourne la somme de
toutes les valeurs sans tenir compte
de la contrainte de poids. Pour trois
objets de poids $2$, $3$, $4$ et de
valeurs $3$, $4$, $5$ avec $W = 5$, il
renvoie $12$ alors que la valeur optimale
vaut $7$.

]]> def sac_a_dos(poids, valeurs, W): n = len(poids) V = [[0] * (W + 1) for _ in range(n + 1)] for i in range(1, n + 1): for w in range(W + 1): if poids[i-1] <= w: V[i][w] = max(V[i-1][w], V[i-1][w-poids[i-1]] + valeurs[i-1]) else: V[i][w] = V[i-1][w] return V[n][W]]]> Bonne réponse : on construit un tableau à
deux dimensions de taille
$(n+1) \times (W+1)$. Pour chaque case
$(i, w)$ : si l'objet $i$ rentre dans le
sac (poids[i-1] <= w), on prend le
maximum entre « ne pas le prendre »
(V[i-1][w]) et « le prendre »
(V[i-1][w-poids[i-1]] + valeurs[i-1]) ;
sinon, on ne peut pas le prendre. Indices
$i-1$ car les listes Python commencent
à $0$.

]]> def sac_a_dos(poids, valeurs, W): # Glouton : meilleur ratio valeur/poids d'abord couples = [] for i in range(len(poids)): couples.append((valeurs[i] / poids[i], i)) total = 0 capa = W for ratio, i in sorted(couples, reverse=True): if poids[i] <= capa: total += valeurs[i] capa -= poids[i] return total]]> Erreur : c'est l'algorithme glouton par
ratio valeur/poids. Il est optimal pour
le sac à dos fractionnaire (où l'on
peut couper des objets), mais pas pour
la version $0/1$. Pour des poids $1$,
$2$, $3$, des valeurs $6$, $10$, $12$ et
$W = 5$, il prend l'objet de ratio $6$
puis celui de ratio $5$ et renvoie $16$,
alors que les objets de poids $2$ et $3$
donnent $22$.

]]> def sac_a_dos(poids, valeurs, W): n = len(poids) V = [[0] * (W + 1) for _ in range(n + 1)] for i in range(1, n + 1): for w in range(W + 1): if poids[i-1] <= w: V[i][w] = max(V[i-1][w], V[i][w-poids[i-1]] + valeurs[i-1]) else: V[i][w] = V[i-1][w] return V[n][W]]]> Erreur : dans le second terme du max,
la case consultée est V[i][w-poids[i-1]]
(ligne $i$ au lieu de $i-1$), ce qui
autorise à reprendre l'objet $i$
plusieurs fois. C'est le sac à dos
non borné, pas la version $0/1$.
Avec un seul objet de poids $2$ et de
valeur $3$ pour $W = 4$, ce code renvoie
$6$ (l'objet pris deux fois) au lieu de
$3$.

]]> Programmation dynamique — Q31 : Mesurer le gain de la mémoïsation On compare le calcul de fibonacci(40) avec
la version récursive naïve et avec la
version mémoïsée. Quel est l'ordre de
grandeur du rapport entre les deux
complexités ?

]]> Cet exemple illustre la puissance de la
programmation dynamique. Bien sûr, pour
Fibonacci en pratique, on utilise plutôt la
version itérative à deux variables, qui a
la même complexité $O(n)$ mais avec une
consommation mémoire $O(1)$ au lieu de
$O(n)$.

]]> 1.0 0.0 0 true true abc Les deux versions ont la même complexité
asymptotique

]]> Erreur : la mémoïsation change
fondamentalement la complexité. La
version naïve calcule plusieurs fois
les mêmes valeurs (par exemple,
$\mathrm{fib}(35)$ est calculée
plusieurs millions de fois) ; la
mémoïsée ne calcule chaque valeur qu'une
seule fois.

]]> La version mémoïsée est environ deux fois
plus rapide

]]> Erreur : un facteur deux serait une
amélioration mineure. Or le passage de
$O(2^n)$ à $O(n)$ représente un gain
exponentiel, pas multiplicatif. Pour
$n = 40$, c'est un facteur de plus de
dix milliards.

]]> La version mémoïsée est plus lente à
cause du surcoût du cache

]]> Erreur : pour $n$ aussi petit que $20$,
le surcoût du cache est négligeable
devant le gain en évitant les calculs
redondants. Pour $n = 40$, le gain est
colossal.

]]> La version mémoïsée est environ
$10^{10}$ fois plus rapide

]]> Bonne réponse : version naïve en
$O(2^n)$, soit environ
$2^{40} \approx 10^{12}$ appels
récursifs. Version mémoïsée en $O(n)$,
soit environ $40$ appels effectifs. Le
rapport est donc d'environ
$10^{12} / 40 \approx 2{,}5 \cdot 10^{10}$.
En pratique, on passe de plusieurs
minutes à une fraction de milliseconde.

]]> Programmation dynamique — Q32 : Monter un escalier une ou deux marches à la fois Pour monter un escalier de $4$ marches, on avance d'une ou de
deux marches à chaque pas. Le nombre de façons $E(n)$ vérifie
$E(n) = E(n-1) + E(n-2)$ avec $E(1) = 1$ et $E(2) = 2$. Combien de
façons de monter $4$ marches ?

]]> La dernière marche est atteinte soit depuis la précédente, soit
depuis l'avant-dernière : la récurrence est celle de Fibonacci, et
la tabulation évite tout recalcul.

]]> 1.0 0.0 0 true true abc $5$

]]> Bonne réponse : en remplissant la table de proche en proche,
$E(3) = 3$, puis $E(4) = 5$, et ainsi de suite jusqu'à
$E(4) = 5$.

]]> $3$

]]> Erreur : $3$ est $E(3)$ ; il reste une étape de la
récurrence.

]]> $16$

]]> Erreur : $2^{4}$ compterait des suites de pas sans tenir
compte de la longueur totale.

]]> $8$

]]> Erreur : $8$ est $E(5)$, une marche de trop.

]]> Programmation dynamique — Q33 : La somme maximale d'une tranche Pour trouver la tranche contiguë de somme maximale d'une liste, on
calcule pour chaque position $i$ la meilleure somme d'une tranche
qui se termine en $i$ : $M(i) = t[i] + \max(0, M(i-1))$. Quelle est
la somme maximale pour [-2, 3, -1, 4, -3] ?

]]> Chaque $M(i)$ se déduit du précédent en temps constant : une seule
passe suffit, là où tester toutes les tranches coûterait $n^2$.

]]> 1.0 0.0 0 true true abc $6$, obtenue par la tranche [3, -1, 4]

]]> Bonne réponse : on prolonge la tranche précédente si sa somme est
positive, sinon on repart de $t[i]$. Le maximum des $M(i)$ vaut
$6$.

]]> $1$, la somme de toute la liste

]]> Erreur : la liste entière contient des valeurs négatives qui
font baisser la somme ; une tranche plus courte fait mieux.

]]> $4$, le plus grand élément isolé

]]> Erreur : une tranche peut regrouper plusieurs éléments et
dépasser le maximum isolé, ou, si tout est négatif, s'y
réduire.

]]> $0$, en choisissant la tranche vide

]]> Erreur : la tranche doit contenir au moins un élément.

]]> Programmation dynamique — Q34 : Compter les façons de rendre une somme Avec des pièces de $1$ et de $2$, de combien de façons peut-on
rendre la somme $4$, l'ordre des pièces ne comptant pas ?

]]> Avec plus de valeurs de pièces, on remplit une table
$N(s, k)$, nombre de façons de rendre $s$ avec les $k$ premières
pièces : chaque case se déduit des précédentes.

]]> 1.0 0.0 0 true true abc $3$

]]> Bonne réponse : le nombre de pièces de $2$ va de $0$ à
$2$, le reste étant complété par des $1$ : $1+1+1+1$, $1+1+2$ et $2+2$.

]]> $4$

]]> Erreur : le nombre de façons n'est pas le montant.

]]> $8$

]]> Erreur : ce compte supposerait des choix indépendants, alors
que le total est contraint.

]]> $1$

]]> Erreur : plusieurs répartitions entre pièces de $1$ et de $2$
conviennent.

]]> Programmation dynamique — Q35 : Le triangle de Pascal par tabulation Les coefficients binomiaux vérifient
$C(n, k) = C(n-1, k-1) + C(n-1, k)$ avec $C(n, 0) = C(n, n) = 1$.
En remplissant la table ligne par ligne, que vaut $C(6, 2)$ ?

]]> Calculer $C(n, k)$ par la récurrence sans table recalcule les mêmes
valeurs ; la tabulation construit chaque ligne à partir de la
précédente.

]]> 1.0 0.0 0 true true abc $15$

]]> Bonne réponse : $C(6, 2) = C(5, 1) + C(5, 2) =
5 + 10 = 15$, chaque terme venant de la ligne précédente.

]]> $8$

]]> Erreur : la récurrence additionne deux coefficients, pas $n$ et
$k$.

]]> $12$

]]> Erreur : $6 \times 2$ n'a rien à voir avec la récurrence.

]]> $10$

]]> Erreur : $10$ est $C(5, 2)$, il manque l'autre terme.

]]> Programmation dynamique — Q36 : Quand la programmation dynamique n'apporte rien Le tri fusion découpe la liste en deux moitiés et les trie
récursivement. La programmation dynamique peut-elle l'accélérer ?

]]> Diviser pour régner et programmation dynamique se distinguent par
le chevauchement des sous-problèmes : absent dans le premier,
central dans la seconde.

]]> 1.0 0.0 0 true true abc Non, aucun sous-problème n'y est résolu deux fois

]]> Bonne réponse : chaque moitié n'est triée qu'une fois. Sans
chevauchement de sous-problèmes, mémoriser les résultats ne sert
à rien.

]]> Oui, en mémorisant chaque fusion dans un dictionnaire

]]> Erreur : chaque fusion n'est faite qu'une fois ; la mémoriser
coûterait sans rien économiser.

]]> Oui, tout algorithme récursif en profite de la même façon

]]> Erreur : seuls ceux dont les sous-problèmes se répètent en
profitent.

]]> Non, car le tri fusion n'est pas un algorithme récursif

]]> Erreur : il l'est ; la raison est l'absence de chevauchement.

]]> Programmation dynamique — Q37 : Combien de fois le même sous-problème Dans le calcul récursif naïf de fib(6), combien de fois
fib(2) est-il calculé ?
def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

]]> Le chevauchement des sous-problèmes se mesure : ici les petits
termes sont recalculés un nombre exponentiel de fois.

]]> 1.0 0.0 0 true true abc $5$ fois

]]> Bonne réponse : le nombre d'appels à fib(2) dans fib(n) est
$F(n-1)$, le terme de Fibonacci lui-même : $5$ pour
$n = 6$. Un seul calcul suffirait.

]]> $1$ fois

]]> Erreur : c'est le cas avec mémoïsation ; sans elle, l'arbre
d'appels répète ce sous-problème.

]]> $12$ fois

]]> Erreur : le compte ne suit pas une loi linéaire en $n$.

]]> $6$ fois

]]> Erreur : le compte suit la suite de Fibonacci, pas $n$.

]]> Programmation dynamique — Q38 : Le point de départ d'une solution dynamique Par quoi commence la conception d'une solution par programmation
dynamique ?

]]> Récurrence, table, ordre de remplissage, lecture du résultat : les
quatre temps d'une programmation dynamique.

]]> 1.0 0.0 0 true true abc Par une relation de récurrence entre sous-problèmes

]]> Bonne réponse : sans récurrence, rien à mémoriser ni à tabuler.
Le choix de la table et l'ordre de remplissage en découlent.

]]> Par le choix du langage et des structures de données

]]> Erreur : la méthode est indépendante du langage.

]]> Par la mesure du temps d'exécution de la version naïve

]]> Erreur : mesurer peut motiver, mais ne construit pas la
solution.

]]> Par le tri des données d'entrée par ordre croissant

]]> Erreur : le tri n'est pas une étape générale de la méthode.

]]> Programmation dynamique — Q39 : Mémoïser une fonction à deux arguments La fonction valeur(i, w) du sac à dos dépend de deux entiers.
Comment organiser sa mémoïsation avec un dictionnaire memo ?

]]> La clé de mémoïsation doit déterminer entièrement l'appel : un
tuple de tous les arguments, ou une table à deux dimensions.

]]> 1.0 0.0 0 true true abc Avec la clé (i, w), un tuple

]]> Bonne réponse : un tuple est immuable et identifie le couple
d'arguments ; memo[(i, w)] retrouve le résultat déjà calculé.

]]> Avec la clé i seulement, w variant peu

]]> Erreur : deux appels de même i et de w différents auraient
des résultats différents mais la même clé.

]]> Avec la clé i + w, la somme des deux

]]> Erreur : (2, 3) et (3, 2) auraient la même clé pour des
résultats différents.

]]> Avec une liste [i, w] comme clé

]]> Erreur : une liste n'est pas utilisable comme clé de
dictionnaire.

]]>