$course$/QCM de NSI/Première/Algorithmes gloutons Principe des algorithmes gloutons, notion de choix
localement optimal, exemples classiques (rendu de
monnaie, sac à dos fractionnaire, sélection
d'activités), cas où l'algorithme glouton donne
l'optimum, et contre-exemples qui montrent ses
limites.

]]> Algorithmes gloutons — Q01 : Définition d'un algorithme glouton Quel est le principe d'un algorithme glouton ?

]]> Un algorithme glouton est rapide et simple à écrire, mais il ne
garantit pas la meilleure solution sur tous les problèmes : pour
rendre $6$ avec des pièces de $1$, $3$ et $4$, il donne
$4 + 1 + 1$ alors que $3 + 3$ suffit.

]]> 1.0 0.0 0 true true abc Il choisit toujours au hasard parmi les options disponibles

]]> Un algorithme glouton est déterministe : à
chaque étape, il applique un critère précis
(« le plus grand », « le plus court », etc.)
plutôt qu'un tirage aléatoire.

]]> Il essaie chaque possibilité, abandonne quand la solution échoue, puis revient en arrière pour explorer une autre voie

]]> Cette description suppose de revenir sur des choix déjà faits pour
explorer une autre voie. Un algorithme glouton, au contraire, ne
revient jamais sur ses choix, et c'est précisément ce qui le
caractérise.

]]> À chaque étape, il fait le choix qui semble localement le meilleur, sans jamais revenir en arrière

]]> C'est exactement cela : un algorithme glouton
prend une décision irrévocable à chaque étape,
en espérant que la succession des choix locaux
mène à un optimum global.

]]> Il essaie toutes les solutions possibles, puis garde la meilleure

]]> Cette description correspond à la recherche exhaustive, et non à la stratégie gloutonne.
Un algorithme glouton ne teste qu'une seule
solution, en construisant son choix étape par
étape.

]]> Algorithmes gloutons — Q02 : Exemple classique Lequel des problèmes suivants est résolu
naturellement par un algorithme glouton, dans le
système monétaire de l'euro ?

]]> Le rendu de monnaie est l'exemple emblématique
des algorithmes gloutons enseignés en classe. Il
fonctionne bien pour le système euro, mais peut
échouer pour d'autres systèmes monétaires, comme
le montre la question suivante.

]]> 1.0 0.0 0 true true abc Calculer la racine carrée d'un nombre

]]> Le calcul d'une racine carrée n'est pas un
problème d'optimisation : on cherche une
valeur, pas le meilleur choix parmi
plusieurs.

]]> Trier une liste d'entiers

]]> Le tri n'est pas un problème d'optimisation
gloutonne classique. Les algorithmes de tri
étudiés en classe (tri par insertion, tri par
sélection) ne sont pas considérés comme des
algorithmes gloutons.

]]> Le rendu de monnaie (minimum de pièces)

]]> À chaque étape, on prend la plus grande pièce
qui tient encore dans le reste à rendre. Avec
le système euro, cette stratégie donne bien le
nombre minimum de pièces.

]]> Vérifier si une chaîne de caractères est un palindrome

]]> Tester si une chaîne est un palindrome relève
d'un problème de comparaison, pas
d'optimisation. Aucun choix successif n'est
fait.

]]> Algorithmes gloutons — Q03 : Contre-exemple du rendu de monnaie Avec le système hypothétique de pièces
$\{1, 3, 4\}$, on veut rendre $6$. Que donne
l'algorithme glouton qui prend la plus grande
pièce possible à chaque étape ?

]]> Cet exemple illustre la limite des algorithmes
gloutons : ils ne garantissent pas l'optimum sur
tous les systèmes monétaires. Le système euro
est conçu de telle sorte que la stratégie
gloutonne donne toujours le minimum de pièces,
mais ce n'est pas une propriété universelle.

]]> 1.0 0.0 0 true true abc L'algorithme glouton ne termine pas

]]> Un algorithme glouton termine toujours en un
nombre fini d'étapes, car le reste à rendre
diminue strictement à chaque étape jusqu'à
atteindre zéro.

]]> $4 + 1 + 1 = 6$, soit trois pièces

]]> L'algorithme glouton commence par prendre la
pièce de $4$, puis deux pièces de $1$, ce qui
fait trois pièces au total. Or, l'optimum
réel est $3 + 3 = 6$, soit deux pièces
seulement. L'algorithme glouton n'a donc pas
trouvé la meilleure solution.

]]> $3 + 3 = 6$, soit deux pièces

]]> C'est bien la solution optimale, mais
l'algorithme glouton naïf ne la trouve pas.
Il commence par prendre la plus grande pièce
qui tient (la pièce de $4$) plutôt que de
chercher une combinaison plus astucieuse.

]]> $1 + 1 + 1 + 1 + 1 + 1 = 6$, soit six pièces

]]> Un algorithme glouton ne prend pas
systématiquement la plus petite pièce, mais la
plus grande qui tient encore dans le reste à
rendre.

]]> Algorithmes gloutons — Q04 : Caractéristiques d'un algorithme glouton Lequel des énoncés suivants est vrai pour les
algorithmes gloutons ?

]]> Les principaux avantages des algorithmes
gloutons sont leur simplicité et leur rapidité.
Leur principal inconvénient est qu'ils ne sont
pas toujours optimaux. Ils constituent
néanmoins un bon premier réflexe à essayer face
à un problème d'optimisation.

]]> 1.0 0.0 0 true true abc Ils sont en général rapides, mais pas toujours optimaux

]]> C'est précisément le compromis qui caractérise
les algorithmes gloutons. Leur rapidité
(typiquement linéaire ou quasi-linéaire) en
fait un excellent premier essai, mais il faut
vérifier ensuite qu'ils donnent l'optimum sur
le problème considéré.

]]> Ils essaient toutes les solutions avant de choisir la meilleure

]]> C'est la description de la recherche
exhaustive. Un algorithme glouton ne construit
qu'une seule solution, sans énumérer les
alternatives.

]]> Ils ont toujours une complexité exponentielle

]]> C'est plutôt la recherche exhaustive qui a
souvent une complexité exponentielle. Les
algorithmes gloutons sont au contraire connus
pour leur rapidité.

]]> Ils ne fonctionnent que sur les listes triées

]]> Aucune contrainte n'est imposée sur la nature
des données d'entrée. De nombreux algorithmes
gloutons commencent simplement par un tri,
mais ce n'est pas une exigence générale.

]]> Algorithmes gloutons — Q05 : Critère de choix glouton Pour résoudre un problème d'optimisation par un
algorithme glouton, quelle question doit-on se
poser en premier ?

]]> Une bonne pratique consiste à tester plusieurs
critères de choix sur des exemples connus, puis,
lorsque c'est possible, à démontrer
mathématiquement que le critère retenu mène à
l'optimum.

]]> 1.0 0.0 0 true true abc Quelle est la taille du problème ?

]]> La taille du problème influence la
performance, mais elle n'a aucune incidence
sur la conception même de l'algorithme
glouton.

]]> Quel critère local utiliser pour décider à chaque étape ?

]]> La conception d'un algorithme glouton commence
toujours par le choix d'un critère local :
prendre la plus grande pièce, le plus court
chemin, l'objet de plus grande valeur, et
ainsi de suite. Ce choix détermine entièrement
l'algorithme.

]]> Combien de cœurs possède le processeur ?

]]> Le nombre de cœurs concerne le matériel et
n'a aucun rapport avec la stratégie
algorithmique adoptée.

]]> Quel est le langage de programmation utilisé ?

]]> Le langage de programmation n'a aucune
influence sur la stratégie algorithmique. Un
algorithme glouton se conçoit indépendamment
de Python, Java ou tout autre langage.

]]> Algorithmes gloutons — Q07 : Pas de retour en arrière Quelle propriété distingue un algorithme glouton
des autres stratégies algorithmiques ?

]]> Lorsque l'algorithme glouton donne l'optimum,
c'est la stratégie la plus économique
(rapidité, simplicité). Mais dès qu'il faut
explorer plusieurs alternatives pour ne pas se
faire piéger, il faut recourir à d'autres
techniques, étudiées en classe de terminale.

]]> 1.0 0.0 0 true true abc Il essaie toutes les solutions possibles avant de répondre

]]> C'est la description de la recherche
exhaustive. L'algorithme glouton fait
précisément l'inverse : il prend une seule
décision à chaque étape, sans rien essayer
d'autre.

]]> Il ne fonctionne que sur des listes triées

]]> Aucune contrainte n'est imposée sur la nature
ou l'ordre des données d'entrée.

]]> Il fait toujours un choix aléatoire à chaque étape

]]> Un algorithme glouton est déterministe :
il applique un critère précis pour faire son
choix, et non un tirage aléatoire.

]]> Il ne revient jamais sur ses décisions : un choix fait reste définitif

]]> C'est la caractéristique majeure d'un
algorithme glouton. Cette absence de retour en
arrière garantit sa rapidité, mais peut aussi
l'empêcher de trouver l'optimum lorsqu'un
mauvais choix initial bloque la suite.

]]> Algorithmes gloutons — Q08 : Coût d'un algorithme glouton Quel est typiquement le coût d'un algorithme glouton ?

]]> Cette rapidité fait des algorithmes gloutons
d'excellents premiers candidats. Si l'on doute
de leur optimalité, on peut les comparer à une
solution exacte sur de petits exemples, ou
chercher un contre-exemple.

]]> 1.0 0.0 0 true true abc Proportionnel au nombre de solutions possibles

]]> Un coût proportionnel au nombre de solutions possibles correspond à
l'essai de toutes les solutions, c'est-à-dire à la recherche
exhaustive. Un algorithme glouton fait précisément l'inverse : il
construit une seule solution.

]]> Faible, souvent linéaire

]]> Un algorithme glouton parcourt typiquement les éléments une seule
fois (coût linéaire), après les avoir parfois triés selon son
critère. Cette rapidité est l'un de ses principaux atouts.

]]> Exponentiel

]]> Un coût exponentiel correspond plutôt à la recherche exhaustive. Un
algorithme glouton est au contraire connu pour sa rapidité.

]]> Indéfini, selon les cas rencontrés

]]> Le coût est parfaitement défini pour chaque algorithme glouton
concret : il dépend de la structure du problème et du critère
choisi.

]]> Algorithmes gloutons — Q09 : Algorithme glouton de rendu de monnaie en Python Voici le squelette d'un algorithme glouton de
rendu de monnaie :

def rendu(montant, pieces):
    pieces = sorted(pieces, reverse=True)
    resultat = []
    for p in pieces:
        while montant >= p:
            resultat.append(p)
            montant -= p
    return resultat

Que fait l'instruction
pieces = sorted(pieces, reverse=True) ?

]]> Cette ligne est essentielle. Sans tri préalable,
l'algorithme parcourrait les pièces dans
l'ordre de la liste, ce qui ne correspondrait
plus à la stratégie gloutonne.

]]> 1.0 0.0 0 true true abc Elle compte le nombre de pièces

]]> La fonction sorted ne compte pas, elle
trie. Pour compter les éléments d'une liste,
on utilise plutôt la fonction native len.

]]> Elle trie les pièces par ordre décroissant

]]> Ce tri est cohérent avec la stratégie
gloutonne du rendu de monnaie. À chaque
étape, l'algorithme prend la plus grande
pièce qui tient encore dans le reste à
rendre.

]]> Elle mélange les pièces de manière aléatoire

]]> La fonction sorted est strictement
déterministe : elle trie selon un ordre
précis, et ne mélange jamais aléatoirement.

]]> Elle trie les pièces par ordre croissant

]]> L'argument reverse=True inverse l'ordre du
tri. La liste est donc triée par ordre
décroissant, et non croissant.

]]> Algorithmes gloutons — Q10 : Choix irrévocable Une caractéristique fondamentale d'un algorithme
glouton est que ses choix sont :

]]> Le mot « glouton » vient de l'image d'un mangeur
qui prend immédiatement ce qu'il préfère, sans
planification d'ensemble. Cette image traduit
bien la nature locale et irrévocable des choix
effectués par l'algorithme.

]]> 1.0 0.0 0 true true abc Irrévocables : aucun retour en arrière

]]> Cette irrévocabilité rend l'algorithme rapide
(puisqu'il n'y a aucune exploration à mener),
mais aussi limité : un mauvais choix initial
peut bloquer la suite et empêcher d'atteindre
l'optimum.

]]> Toujours optimaux globalement par construction

]]> Un choix glouton est optimal localement,
mais cette optimalité locale n'entraîne pas
automatiquement l'optimalité globale. Tout
l'enjeu est précisément de trouver un
critère pour lequel cette implication soit
vraie.

]]> Aléatoires à chaque appel

]]> Un algorithme glouton est déterministe : il
applique un critère précis pour faire ses
choix, et donne donc toujours le même
résultat sur la même entrée.

]]> Réversibles à tout moment

]]> C'est précisément l'inverse. Si l'on revenait en arrière sur ses
choix pour en essayer d'autres, ce ne serait plus un algorithme
glouton mais une recherche exhaustive.

]]> Algorithmes gloutons — Q12 : Sac à dos 0/1 et algorithme glouton Pour le sac à dos $0/1$, où chaque objet est
pris entièrement ou pas du tout, pourquoi
l'algorithme glouton fondé sur le ratio
valeur/poids ne donne-t-il pas toujours
l'optimum ?

]]> Pour le sac à dos $0/1$, on utilise une autre
technique étudiée en classe de terminale.
L'algorithme glouton donne souvent une bonne
solution approchée, mais sans garantie
d'optimalité.

]]> 1.0 0.0 0 true true abc Parce que les objets ne sont pas triés

]]> On peut tout à fait trier les objets avant
le parcours. Le problème vient de la nature
combinatoire du cas $0/1$, et non de
l'ordre dans lequel on examine les objets.

]]> Les objets indivisibles bloquent parfois l'optimum

]]> C'est exactement le piège. Avec des objets
indivisibles, prendre l'objet au meilleur
ratio peut consommer une part importante de
la capacité, sans qu'on puisse compléter par
la combinaison la plus rentable. Une autre
technique est nécessaire pour garantir
l'optimum.

]]> Parce que l'algorithme glouton est beaucoup trop lent

]]> La rapidité n'est pas en cause : l'algorithme
glouton est même plus rapide que les autres
approches. La difficulté tient bien à
l'optimalité du résultat, pas au temps de
calcul.

]]> Parce que l'algorithme manque toujours de mémoire

]]> La consommation mémoire d'un algorithme
glouton est très faible. Le problème ne
vient absolument pas de là.

]]> Algorithmes gloutons — Q15 : Trace du rendu de monnaie Avec la stratégie gloutonne (« prendre la plus
grande pièce ne dépassant pas le reste à
rendre ») et les pièces $\{1, 2, 5, 10\}$, quel
est le rendu pour la valeur $18$ ?

]]> Avec ce système monétaire, l'algorithme glouton
donne bien l'optimum. Mais ce n'est pas
toujours le cas. Avec le système $\{1, 3, 4\}$
pour rendre $6$, l'algorithme glouton donne
$4 + 1 + 1$, soit trois pièces, alors que
l'optimum est $3 + 3$, soit deux pièces.

]]> 1.0 0.0 0 true true abc $10 + 5 + 2 + 1 = 18$, soit quatre pièces

]]> Le déroulé est le suivant : $18 = 10 + 8$,
puis $8 = 5 + 3$, puis $3 = 2 + 1$, soit
quatre pièces au total. C'est aussi
l'optimum pour ce système monétaire.

]]> $5 + 5 + 5 + 2 + 1 = 18$, soit cinq pièces

]]> L'algorithme glouton ne prend pas plusieurs
pièces de $5$ alors qu'une pièce de $10$ est
disponible. Il choisit toujours la plus
grande pièce qui tient encore dans le reste
à rendre.

]]> La pièce de $1$ répétée dix-huit fois

]]> L'algorithme glouton choisit la plus grande pièce possible à chaque étape, et
non la plus petite. Cette solution serait
la pire possible.

]]> $10 + 10 = 20$

]]> Cette somme dépasse $18$. L'algorithme
glouton ne choisit jamais une pièce qui
excéderait le reste à rendre.

]]> Algorithmes gloutons — Q16 : Réserver le gymnase pour le plus de clubs Cinq clubs demandent le gymnase, chacun sur un créneau (heure de
début, heure de fin) : A $(8, 12)$, B $(9, 10)$, C $(10, 11)$,
D $(11, 13)$ et E $(12, 14)$. Un créneau peut suivre un autre s'il
commence à l'heure de fin de celui-ci ou plus tard. L'algorithme
glouton range les créneaux par heure de fin croissante, puis retient
chaque créneau qui peut suivre le dernier créneau retenu. Quels
créneaux retient-il ?

]]> Choisir à chaque étape le créneau qui finit le plus tôt laisse le
plus de temps libre pour la suite. Ici, aucun ensemble de quatre
créneaux compatibles n'existe : trois clubs est le maximum.

]]> 1.0 0.0 0 true true abc A et E

]]> Erreur : ce résultat vient d'un tri par heure de début. A, qui
commence le plus tôt, occupe le gymnase jusqu'à $12$ et écarte B,
C et D.

]]> B et D

]]> Erreur : C commence à $10$, exactement quand B finit, il peut donc
le suivre. En exigeant un début strictement après la fin, on
écarte C à tort.

]]> B, C et D

]]> Bonne réponse : l'ordre par fin croissante est B, C, A, D, E. On
retient B (fin $10$), puis C qui commence à $10$ (fin $11$) ; A
commence à $8$, trop tôt ; D commence à $11$ (fin $13$) ; E
commence à $12$, avant $13$.

]]> B, C, D et E

]]> Erreur : E commence à $12$, alors que D, déjà retenu, finit à $13$.
Les deux créneaux se chevauchent, E doit être écarté.

]]> Algorithmes gloutons — Q17 : Tri par critère personnalisé Pour préparer un sac à dos fractionnaire, on veut
trier une liste objets de dictionnaires de la
forme {"valeur": 60, "poids": 10} par ratio
valeur / poids décroissant. On a défini la
fonction clé :
def ratio(objet):
    return objet["valeur"] / objet["poids"]

Quelle écriture renvoie la liste triée voulue ?

]]> Dans un algorithme glouton, on commence souvent
par trier les candidats selon le critère de
choix, en passant à sorted une fonction clé
nommée, puis on les parcourt dans cet ordre
pour construire la solution.

]]> 1.0 0.0 0 true true abc sorted(objets, key=ratio, reverse=True)

]]> Le paramètre key reçoit la fonction ratio
elle-même (sans parenthèses), que Python
appelle sur chaque objet pour calculer sa
clé, et reverse=True inverse l'ordre
croissant par défaut.

]]> sorted(objets, reverse=True)

]]> Sans paramètre key, Python compare les
dictionnaires directement entre eux, ce qui
n'est pas défini : TypeError ('<' not
supported between instances of 'dict' and
'dict').

]]> sorted(objets, key='ratio', reverse=True)

]]> Le paramètre key attend une fonction,
pas son nom entre guillemets : Python tente
d'appeler la chaîne 'ratio' sur chaque
objet et lève TypeError ('str' object is
not callable).

]]> sorted(objets, key=ratio)

]]> Le tri se fait selon le bon critère, mais
dans l'ordre croissant des ratios :
l'objet le moins rentable arrive en premier.
Il manque reverse=True pour placer en tête
les objets de plus grand ratio.

]]> Algorithmes gloutons — Q18 : Méthode pour concevoir un algorithme glouton Quelles étapes sont conseillées pour concevoir
un algorithme glouton sur un nouveau problème ?

]]> Cette méthode est aussi celle des chercheurs en
algorithmique. Trouver un contre-exemple est
souvent rapide et suffit à invalider un mauvais
critère ; la démonstration formelle de
l'optimalité, lorsqu'elle est possible, relève
de l'enseignement supérieur.

]]> 1.0 0.0 0 true true abc Choisir le premier critère qui paraît simple, sans le tester

]]> La simplicité d'un critère ne garantit pas
son optimalité. Il est indispensable de le
tester sur des exemples et, idéalement, de
le démontrer.

]]> Coder en Python, lancer en production, et espérer que cela fonctionne

]]> Cette approche est dangereuse. Sans
analyse préalable, on risque de produire
des résultats erronés sur certains cas, et
de propager le bug en production.

]]> Demander directement la solution à l'enseignant

]]> Cette démarche n'apporte rien sur le plan de
la formation au raisonnement algorithmique.
Construire soi-même la solution est
précisément ce qu'on cherche à apprendre.

]]> Identifier le critère, tester, chercher un contre-exemple

]]> Cette démarche méthodique commence par le
critère, vérifie son comportement sur des
cas concrets, et se termine par la
recherche d'un contre-exemple éventuel.
Sans la dernière étape, on dispose d'une
heuristique sans garantie sur les cas non
testés.

]]> Algorithmes gloutons — Q19 : Algorithme glouton et recherche exhaustive Quel est l'avantage essentiel d'un algorithme
glouton sur une recherche exhaustive ?

]]> C'est cette rapidité qui justifie l'usage d'un
algorithme glouton, même quand il ne donne pas
l'optimum exact. Sur des données massives,
c'est souvent la seule approche réalisable.

]]> 1.0 0.0 0 true true abc Il garantit toujours l'optimum

]]> C'est l'inverse. La recherche exhaustive
garantit toujours l'optimum (si elle se
termine), tandis qu'un algorithme glouton
ne le garantit pas en général.

]]> Il est bien plus rapide

]]> Sur des problèmes de taille moyenne ou
grande, la différence est colossale. Pour
$n = 30$, on dépasse $10^9$ opérations en
recherche exhaustive, contre quelques
dizaines à quelques centaines pour un
algorithme glouton linéaire.

]]> Il est plus simple à expliquer en classe

]]> La simplicité pédagogique est un avantage
secondaire, mais elle n'est pas l'avantage
principal d'un algorithme glouton.

]]> Il consomme moins de mémoire

]]> La consommation mémoire varie selon les
implémentations et n'est pas l'avantage
principal mis en avant.

]]> Algorithmes gloutons — Q20 : Algorithme glouton comme approximation Lorsque l'algorithme glouton ne donne pas
l'optimum, peut-on quand même l'utiliser ?

]]> Pour le voyageur de commerce, par exemple, un
algorithme glouton du type « plus proche
voisin » donne souvent une tournée à environ
$25\%$ de l'optimum, en temps quadratique.
C'est un compromis très intéressant en
pratique.

]]> 1.0 0.0 0 true true abc Oui, comme approximation rapide

]]> Pour de nombreux problèmes difficiles,
l'algorithme glouton donne une solution en
temps raisonnable, proche du meilleur
résultat connu. Ce compromis entre
rapidité et qualité est très intéressant en
pratique.

]]> Seulement si on retire la contrainte d'optimalité

]]> Cette formulation est imprécise. On peut
utiliser l'algorithme glouton comme
approximation, c'est-à-dire en acceptant
une qualité moindre que l'optimum, mais
sans changer la nature du problème.

]]> Oui, mais seulement avec un ordinateur quantique

]]> Les algorithmes gloutons sont des
algorithmes classiques qui s'exécutent sur
des ordinateurs traditionnels. Ils n'ont
aucun rapport avec l'informatique
quantique.

]]> Non, jamais

]]> Cette position est trop catégorique. Un
algorithme glouton est très souvent utilisé
comme heuristique ou comme algorithme
d'approximation rapide, même quand il ne
garantit pas l'optimum.

]]> Algorithmes gloutons — Q21 : Construire un contre-exemple On vous propose un problème et un algorithme
glouton. Comment démontrer que cet algorithme ne
donne pas toujours l'optimum ?

]]> Un conseil utile : pour les problèmes simples,
essayez de petits exemples « piégés » avec des
asymétries, des poids très différents, ou des
bornes serrées. Un contre-exemple émerge
souvent rapidement.

]]> 1.0 0.0 0 true true abc Vérifier que l'algorithme termine

]]> La terminaison est une propriété
nécessaire mais non suffisante pour
conclure quant à l'optimalité. Un
algorithme peut terminer rapidement et
renvoyer une solution sous-optimale.

]]> Démontrer que l'algorithme est lent

]]> La vitesse de l'algorithme ne dit rien sur
son optimalité. Un algorithme peut être à
la fois très rapide et incapable de
trouver l'optimum.

]]> Trouver un exemple où il fait pire que l'optimum

]]> Un seul contre-exemple suffit pour
invalider un algorithme glouton. C'est la
méthode classique de réfutation en
informatique : un cas particulier qui
contredit l'énoncé général.

]]> Compiler le programme dans plusieurs langages différents

]]> Le langage de programmation utilisé n'a
aucune influence sur l'optimalité du
résultat produit par l'algorithme.

]]> Algorithmes gloutons — Q22 : Algorithme glouton et terminaison Pourquoi un algorithme glouton termine-t-il toujours en un nombre fini d'étapes ?

]]> C'est l'argument du variant : une
quantité entière positive qui décroît
strictement à chaque étape garantit la
terminaison. Pour un algorithme glouton, le
variant est typiquement le nombre d'éléments
candidats restants.

]]> 1.0 0.0 0 true true abc Parce qu'il utilise une boucle while

]]> Une boucle while peut très bien être
infinie. La terminaison ne dépend pas du
type de boucle utilisée, mais de
l'existence d'un variant qui décroît
strictement.

]]> Parce que la mémoire de l'ordinateur est limitée

]]> La limite de mémoire peut provoquer une
erreur d'exécution, mais elle ne garantit
pas la terminaison logique de l'algorithme.

]]> À chaque étape, le nombre de candidats décroît

]]> Le nombre d'éléments candidats décroît
strictement à chaque étape. Comme c'est un
entier positif, l'algorithme s'arrête en
au plus $n$ étapes, où $n$ est le nombre
d'éléments initiaux.

]]> Parce que tous les algorithmes terminent en informatique

]]> Cette affirmation est fausse en général :
de nombreux algorithmes peuvent ne pas
terminer (boucle infinie). Un algorithme
glouton termine pour une raison précise et
structurelle, pas par principe général.

]]> Algorithmes gloutons — Q23 : Vérifier expérimentalement l'optimalité On a écrit un algorithme glouton pour un
nouveau problème d'optimisation. Sans pouvoir
faire de démonstration formelle, comment se
donner une bonne confiance dans le fait
qu'il donne l'optimum sur les cas pratiques ?

]]> Démarche pédagogique en NSI : tester sur des cas concrets, comparer
à une référence (recherche exhaustive ou solution optimale connue),
et chercher des contre-exemples. La démonstration formelle de
l'optimalité d'un algorithme glouton n'est pas exigée au lycée.

]]> 1.0 0.0 0 true true abc Augmenter la taille du problème pour voir
si cela aide

]]> Erreur : tester de plus grandes tailles ne
renseigne pas sur l'optimalité, car on n'a
plus de référence (la recherche exhaustive
devient impraticable). Pour gagner en
confiance, il faut au contraire tester sur
de petites tailles, où l'on peut
comparer à la solution exacte.

]]> Lui faire confiance s'il a été trouvé sur
Internet

]]> Erreur : un algorithme trouvé sur Internet
n'a aucune garantie d'être optimal pour
votre variante du problème. Les conditions
précises (système monétaire, nature des
objets, etc.) modifient souvent l'optimalité
d'un critère glouton.

]]> Lancer le programme une seule fois sur un
exemple et conclure

]]> Erreur : un seul exemple ne prouve rien.
C'est précisément le piège du rendu de
monnaie, qui fonctionne sur le système
euros mais échoue sur d'autres systèmes
monétaires.

]]> Comparer à la recherche exhaustive sur de petits cas

]]> Bonne réponse : c'est la démarche expérimentale standard. La
recherche exhaustive (par exemple en énumérant tous les
sous-ensembles possibles) garantit l'optimum, mais le nombre de cas
double à chaque élément ajouté, ce qui la rend faisable uniquement
pour de petits $n$. Si l'algorithme glouton coïncide avec la
recherche exhaustive sur tous les cas testés, on a une bonne
confiance pratique (sans pour autant disposer d'une preuve
formelle).

]]> Algorithmes gloutons — Q24 : Quelle approche essayer en premier ? Face à un nouveau problème d'optimisation, quelle
approche essayer en premier ?

]]> Démarche conseillée : tester d'abord un
algorithme glouton simple, vérifier sur des cas
connus s'il donne bien l'optimum, et, si un
contre-exemple apparaît, chercher une autre
stratégie ou se contenter d'une approximation.

]]> 1.0 0.0 0 true true abc Aucune méthode particulière, en essayant plusieurs idées au hasard

]]> Une démarche désordonnée ne permet pas de
progresser méthodiquement vers une
solution. Il vaut mieux suivre une approche
structurée comme l'algorithme glouton.

]]> Une recherche exhaustive systématique, pour être certain d'obtenir l'optimum

]]> Tester toutes les combinaisons devient
rapidement impraticable dès que la taille
du problème augmente, car le nombre de cas
croît de manière exponentielle.

]]> Un algorithme glouton simple, rapide à coder et tester

]]> C'est la démarche pragmatique. Beaucoup de
problèmes admettent une solution gloutonne
simple. Inutile de chercher une approche
compliquée si un algorithme glouton suffit
à donner l'optimum.

]]> Une approche aléatoire, sans stratégie particulière

]]> Sans démarche structurée, on ne peut rien
apprendre du problème, et on perd toute
garantie sur la qualité de la solution
obtenue.

]]> Algorithmes gloutons — Q25 : Conclusion sur les algorithmes gloutons Lequel des énoncés suivants résume le mieux les
algorithmes gloutons ?

]]> Maîtriser les algorithmes gloutons, c'est
savoir reconnaître les problèmes qui s'y
prêtent (rendu de monnaie sur certains
systèmes, sac à dos fractionnaire, sélection
d'activités) et savoir détecter ceux qui
demandent une autre approche (sac à dos $0/1$,
voyageur de commerce).

]]> 1.0 0.0 0 true true abc Ils sont rapides et fonctionnent toujours

]]> Cette affirmation est trop optimiste. Les
algorithmes gloutons sont rapides, mais
ils ne donnent pas toujours l'optimum sur
tous les problèmes.

]]> Ils sont totalement obsolètes et sans intérêt aujourd'hui

]]> Les algorithmes gloutons gardent toute leur
pertinence, particulièrement lorsque
l'optimalité est démontrable ou lorsqu'une
approximation rapide suffit pour
l'application visée.

]]> Ils utilisent l'intelligence artificielle

]]> Les algorithmes gloutons sont des
algorithmes classiques et déterministes.
Ils n'ont aucun rapport avec l'apprentissage
automatique ou l'intelligence
artificielle.

]]> Rapides et simples, optimaux parfois, approchés souvent

]]> C'est exactement leur place dans le paysage
algorithmique : un outil indispensable, mais
à utiliser avec discernement, en testant
systématiquement leur comportement sur des
exemples avant de leur faire confiance.

]]> Algorithmes gloutons — Q26 : Rendre une somme avec les pièces de l'euro Avec les pièces et billets de valeurs $1$, $2$, $5$, $10$, $20$ et
$50$, l'algorithme glouton prend à chaque étape la plus grande
valeur qui ne dépasse pas ce qui reste à rendre. Combien de pièces
ou billets rend-il pour la somme $37$ ?

]]> Le système monétaire de l'euro est dit canonique : la stratégie
gloutonne y rend toujours le nombre minimal de pièces.

]]> 1.0 0.0 0 true true abc $4$, soit $20 + 10 + 5 + 2$

]]> Bonne réponse : à chaque étape, la plus grande valeur possible
est choisie, ce qui donne $20 + 10 + 5 + 2 = 37$ en $4$ pièces ou
billets. Avec ce système, le résultat est aussi le minimum.

]]> $5$, soit $20 + 10 + 5 + 2 + 0$

]]> Erreur : recompte les termes de la décomposition, il y en a
$4$.

]]> $3$

]]> Erreur : avec $3$ pièces ou billets, aucune combinaison ne
donne $37$ dans ce système.

]]> $8$

]]> Erreur : $8$ correspondrait à des valeurs bien plus petites que
celles choisies par l'algorithme glouton.

]]> Algorithmes gloutons — Q27 : Le critère du choix d'activités Plusieurs clubs demandent la salle pour des créneaux qui se
chevauchent, et l'on veut satisfaire le plus grand nombre de
demandes. Dans quel ordre l'algorithme glouton examine-t-il les
créneaux ?

]]> Le choix du critère est tout l'art d'un algorithme glouton : pour
les activités, l'heure de fin est le bon, et on peut le prouver.

]]> 1.0 0.0 0 true true abc Par heure de fin croissante, pour libérer la salle au plus tôt

]]> Bonne réponse : finir au plus tôt libère la salle le plus
longtemps pour la suite. Ce critère donne toujours un nombre
maximal de créneaux.

]]> Par heure de début croissante, pour commencer au plus tôt

]]> Erreur : un créneau qui commence tôt mais dure toute la journée
bloquerait tous les autres.

]]> Par durée croissante, pour caser le plus de créneaux courts

]]> Erreur : un créneau court placé au milieu peut empêcher deux
créneaux plus longs qui ne se chevauchaient pas.

]]> Par ordre alphabétique des clubs, pour traiter chacun équitablement

]]> Erreur : l'ordre des noms n'a aucun rapport avec les
chevauchements.

]]> Algorithmes gloutons — Q28 : Le sac à dos par rapport valeur sur poids Un sac supporte un poids de $5$. Trois objets sont
disponibles : A (poids $3$, valeur $60$), B (poids $2$, valeur $50$) et C (poids $4$, valeur $70$). L'algorithme glouton classe les objets par
rapport valeur sur poids décroissant et prend chaque objet qui
tient encore. Quelle valeur totale obtient-il ?

]]> Le rapport valeur sur poids est le critère glouton usuel du sac à
dos. Il ne garantit pas l'optimum : selon la capacité, une autre
combinaison peut valoir davantage.

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

]]> Bonne réponse : l'ordre des rapports est B puis A puis C. L'algorithme
prend B puis A, qui remplissent le sac, pour une valeur de $110$.

]]> $70$

]]> Erreur : suis l'ordre des rapports valeur sur poids et vérifie
le poids restant avant chaque objet.

]]> $50$

]]> Erreur : cette valeur ne correspond pas aux objets pris dans
l'ordre glouton.

]]> $130$

]]> Erreur : cette combinaison dépasse le poids supporté par le sac.

]]> Algorithmes gloutons — Q29 : Le glouton et les pièces de l'euro Avec les pièces et billets de l'euro, l'algorithme glouton de rendu
de monnaie donne-t-il toujours le nombre minimal de pièces ?

]]> L'optimalité d'un glouton dépend du problème et de ses données :
vraie pour l'euro, fausse pour d'autres systèmes monétaires.

]]> 1.0 0.0 0 true true abc Oui, ce système monétaire a été conçu pour cela

]]> Bonne réponse : les valeurs $1$, $2$, $5$, $10$, $20$, $50$
forment un système dit canonique, où prendre la plus grande
pièce possible est toujours optimal.

]]> Non, il faut tester toutes les combinaisons pour être sûr

]]> Erreur : avec ce système précis, l'optimalité du glouton est
démontrée ; la recherche exhaustive est inutile.

]]> Oui, parce qu'un algorithme glouton est toujours optimal

]]> Erreur : la conclusion est bonne mais la raison fausse ;
d'autres systèmes de pièces mettent le glouton en défaut.

]]> Non, le glouton rend parfois une pièce de trop

]]> Erreur : cela arrive avec des systèmes comme $1$, $3$, $4$, pas
avec celui de l'euro.

]]> Algorithmes gloutons — Q30 : Les créneaux retenus Six créneaux sont demandés pour la salle : $[1, 4]$, $[3, 5]$,
$[0, 6]$, $[5, 7]$, $[3, 9]$ et $[6, 10]$. L'algorithme glouton
trie par heure de fin croissante et retient chaque créneau qui
commence après la fin du dernier retenu. Quels créneaux retient-il ?

]]> Deux créneaux sont retenus, et aucune sélection n'en contient
davantage : le critère de la fin au plus tôt est optimal.

]]> 1.0 0.0 0 true true abc $[1, 4]$ et $[5, 7]$

]]> Bonne réponse : $[1, 4]$ finit en premier et est retenu ;
$[3, 5]$ et $[0, 6]$ le chevauchent ; $[5, 7]$ commence après
$4$ et est retenu ; $[3, 9]$ et $[6, 10]$ chevauchent $[5, 7]$.

]]> $[0, 6]$ et $[6, 10]$

]]> Erreur : $[0, 6]$ n'est pas le premier à finir ; $[1, 4]$ le
précède et l'exclut.

]]> $[1, 4]$, $[5, 7]$ et $[6, 10]$

]]> Erreur : $[6, 10]$ commence à $6$, avant la fin de $[5, 7]$ à
$7$, les deux se chevauchent.

]]> $[3, 5]$ et $[5, 7]$

]]> Erreur : $[1, 4]$ finit avant $[3, 5]$ et est examiné en
premier.

]]> Algorithmes gloutons — Q31 : Pourquoi pas le plus court d'abord Pour le choix d'activités, pourquoi le critère « le créneau le plus
court d'abord » n'est-il pas optimal ?

]]> Un contre-exemple suffit à écarter un critère glouton. Trouver le
bon critère, puis prouver qu'il marche toujours, sont deux étapes
distinctes.

]]> 1.0 0.0 0 true true abc Un créneau court à cheval sur deux longs les élimine tous deux

]]> Bonne réponse : avec $[1, 5]$, $[4, 6]$ et $[5, 9]$, le plus
court, $[4, 6]$, est pris en premier et empêche les deux autres,
alors que $[1, 5]$ et $[5, 9]$ étaient compatibles.

]]> Un créneau court rapporte moins qu'un créneau long au classement

]]> Erreur : tous les créneaux comptent pour un, la durée n'a pas de
valeur en soi.

]]> Les créneaux courts sont toujours en fin de journée

]]> Erreur : rien ne lie la durée d'un créneau à sa position.

]]> Le tri par durée est trop coûteux à calculer pour de longues listes

]]> Erreur : trier par durée coûte autant que trier par heure de
fin ; le problème est le résultat, pas le coût.

]]> Algorithmes gloutons — Q32 : Les arrêts d'une voiture électrique Une voiture a $300$ km d'autonomie et part batterie pleine. Des
bornes se trouvent aux kilomètres $100$, $180$, $250$, $400$ et
$520$, l'arrivée au kilomètre $600$. L'algorithme glouton va à
chaque fois jusqu'à la dernière borne atteignable. Où
s'arrête-t-elle ?

]]> Aller aussi loin que possible à chaque étape minimise le nombre
d'arrêts : c'est un glouton dont l'optimalité se démontre.

]]> 1.0 0.0 0 true true abc Au kilomètre $250$, puis au kilomètre $520$

]]> Bonne réponse : depuis $0$, la dernière borne atteignable sous
$300$ km est $250$ ; depuis $250$, on atteint jusqu'à $550$,
d'où un arrêt à $520$, puis l'arrivée. Deux arrêts, c'est le
minimum.

]]> Au kilomètre $100$, puis au kilomètre $400$

]]> Erreur : s'arrêter à la première borne n'est pas glouton, et
$400$ est hors de portée depuis $100$.

]]> Au kilomètre $250$, puis au kilomètre $400$

]]> Erreur : depuis $250$, la borne $520$ est encore atteignable, et
l'algorithme choisit la plus lointaine.

]]> Au kilomètre $180$, puis au kilomètre $400$

]]> Erreur : depuis $0$, $250$ est atteignable, donc $180$ n'est pas
le choix glouton.

]]> Algorithmes gloutons — Q33 : Pourquoi trier avant de choisir Beaucoup d'algorithmes gloutons commencent par trier les données
selon le critère de choix. Qu'y gagne-t-on ?

]]> Tri puis parcours : le schéma donne un coût en $n \log n$ dominé par
le tri, bien plus faible qu'une recherche du meilleur élément à
chaque étape.

]]> 1.0 0.0 0 true true abc Le meilleur choix local devient le prochain élément de la liste

]]> Bonne réponse : une fois trié, il suffit de parcourir la liste
dans l'ordre ; chaque étape se fait en temps constant au lieu de
rechercher le meilleur élément à chaque fois.

]]> Le résultat devient optimal, quel que soit le problème

]]> Erreur : trier ne change pas la qualité des choix, seulement
leur coût.

]]> Les données triées occupent moins de mémoire une fois rangées

]]> Erreur : trier ne réduit pas la taille des données.

]]> On évite d'avoir à parcourir la liste après le tri

]]> Erreur : la liste est parcourue une fois après le tri ; ce qui
est évité, ce sont les recherches répétées.

]]> Algorithmes gloutons — Q34 : Une seule solution construite Combien de solutions candidates un algorithme glouton construit-il
avant de rendre sa réponse ?

]]> Glouton veut dire pressé : on avance sans jamais revenir en
arrière ni comparer avec une autre solution.

]]> 1.0 0.0 0 true true abc Une seule, bâtie choix après choix

]]> Bonne réponse : chaque étape fixe un choix définitif. La
solution rendue est la seule explorée, ce qui rend l'algorithme
rapide mais parfois non optimal.

]]> Toutes, pour retenir la meilleure

]]> Erreur : c'est la recherche exhaustive, dont le coût explose
avec la taille des données.

]]> Deux, pour comparer et garder la meilleure

]]> Erreur : il n'y a aucune comparaison entre solutions, seulement
des choix locaux successifs.

]]> Autant que de données en entrée

]]> Erreur : le nombre de données fixe le nombre d'étapes, pas le
nombre de solutions construites.

]]> Algorithmes gloutons — Q35 : Trois critères pour le sac à dos Pour remplir un sac à dos de capacité limitée avec des objets de
poids et de valeurs variés, trois critères gloutons sont possibles :
la valeur la plus grande d'abord, le poids le plus petit d'abord, ou
le rapport valeur sur poids le plus grand d'abord. Que peut-on en
dire ?

]]> Le sac à dos est l'exemple type d'un problème où le glouton est
une bonne heuristique sans être une méthode exacte.

]]> 1.0 0.0 0 true true abc Aucun ne garantit l'optimum, le rapport étant souvent le meilleur

]]> Bonne réponse : chaque critère a ses contre-exemples. Le rapport
valeur sur poids donne souvent de bons résultats, mais seule une
recherche exhaustive assure l'optimum.

]]> Le critère de la valeur est toujours optimal, quel que soit le sac

]]> Erreur : un objet très lourd et précieux peut remplir le sac
alors que plusieurs petits objets vaudraient plus ensemble.

]]> Le critère du poids est toujours optimal, quels que soient les objets

]]> Erreur : prendre les objets légers peut remplir le sac de
choses sans valeur.

]]> Les trois critères donnent toujours le même résultat

]]> Erreur : ils peuvent choisir des objets différents et aboutir à
des valeurs différentes.

]]> Algorithmes gloutons — Q36 : Affirmer qu'un glouton est optimal Un algorithme glouton a donné la solution optimale sur dix exemples
testés. Que faut-il pour affirmer qu'il est optimal en général ?

]]> Un glouton correct se démontre ; un glouton faux se réfute par un
contre-exemple. Les tests ne font que suggérer.

]]> 1.0 0.0 0 true true abc Une preuve que chaque choix local reste compatible avec un optimum

]]> Bonne réponse : c'est l'argument d'échange classique. Des
exemples réussis ne prouvent rien ; un seul contre-exemple
suffirait à réfuter.

]]> Cent exemples de plus, tous réussis, sur des données variées

]]> Erreur : aucun nombre d'exemples ne remplace une preuve ; le
contre-exemple peut être le suivant.

]]> Que l'algorithme soit rapide sur tous les exemples testés

]]> Erreur : la vitesse d'un glouton est acquise ; c'est la qualité
de sa réponse qui est en question.

]]> Que les exemples testés soient de grande taille et nombreux

]]> Erreur : la taille des exemples ne change rien au raisonnement.

]]> Algorithmes gloutons — Q37 : Un système de pièces qui piège le glouton Avec les pièces de valeurs $1$, $4$ et $6$, on rend la somme $8$.
Combien de pièces donne l'algorithme glouton, et quel est le nombre
minimal de pièces ?

]]> Changer les valeurs des pièces suffit à faire échouer le glouton :
c'est la différence entre un système canonique et un système qui ne
l'est pas.

]]> 1.0 0.0 0 true true abc Glouton $3$ pièces, minimum $2$

]]> Bonne réponse : le glouton donne $6 + 1 + 1$, soit $3$ pièces,
alors que $4 + 4$ n'en utilise que $2$. Ce système n'est pas
canonique.

]]> Glouton $2$ pièces, minimum $3$

]]> Erreur : le minimum ne peut pas dépasser ce que donne le
glouton ; les deux nombres sont inversés.

]]> $3$ pièces dans les deux cas

]]> Erreur : $4 + 4 = 8$ n'utilise que $2$ pièces.

]]> $2$ pièces dans les deux cas

]]> Erreur : le glouton commence par la pièce de $6$ et aboutit à
$6 + 1 + 1$, soit $3$ pièces.

]]> Algorithmes gloutons — Q38 : Toujours la ville la plus proche Pour visiter plusieurs villes et revenir au départ en parcourant le
moins de kilomètres possible, un algorithme glouton va à chaque
étape vers la ville non visitée la plus proche. Que vaut cette
méthode ?

]]> Le voyageur de commerce n'a pas d'algorithme efficace connu ; le
plus proche voisin est une heuristique, utile faute de mieux.

]]> 1.0 0.0 0 true true abc Rapide, mais le circuit peut être bien plus long que le meilleur

]]> Bonne réponse : les premières étapes, courtes, peuvent laisser
pour la fin une ville très éloignée, et le retour coûte alors
plus que tout le reste.

]]> Elle donne toujours le circuit le plus court possible

]]> Erreur : des contre-exemples simples existent, avec quatre ou
cinq villes.

]]> Elle ne termine jamais, les villes proches étant revisitées

]]> Erreur : chaque ville visitée est écartée, et l'algorithme
termine en autant d'étapes que de villes.

]]> Elle est aussi coûteuse que l'examen de tous les circuits

]]> Erreur : elle est bien plus rapide ; c'est son résultat qui
n'est pas garanti.

]]> Algorithmes gloutons — Q39 : Le plus précieux d'abord Un sac supporte un poids de $10$. Trois objets : A pèse $10$ et vaut
$60$, B pèse $5$ et vaut $40$, C pèse $5$ et vaut $40$. Que donne
le glouton qui prend l'objet de plus grande valeur en premier, et
quel est l'optimum ?

]]> Un seul exemple suffit à montrer que le critère de la valeur n'est
pas optimal pour le sac à dos.

]]> 1.0 0.0 0 true true abc A pour $60$, alors que B et C ensemble valent $80$

]]> Bonne réponse : A remplit le sac à lui seul. Le glouton par
valeur rend $60$, tandis que B et C, qui tiennent ensemble,
rendent $80$.

]]> B et C pour $80$, ce qui est aussi l'optimum

]]> Erreur : trié par valeur, A vient en premier et est pris
puisqu'il tient dans le sac.

]]> A puis B pour $100$, le poids n'étant vérifié qu'à la fin

]]> Erreur : après A, le sac est plein, B ne tient plus.

]]> A pour $60$, ce qui est aussi l'optimum

]]> Erreur : B et C valent $80$ ensemble, pour un poids de $10$.

]]> Algorithmes gloutons — Q40 : Le nombre de combinaisons à examiner Pour résoudre exactement un sac à dos à $20$ objets, la recherche
exhaustive examine tous les sous-ensembles d'objets. Combien y en
a-t-il ?

]]> Le nombre de sous-ensembles double à chaque objet ajouté : la
recherche exhaustive devient vite impraticable, d'où le recours
aux algorithmes gloutons.

]]> 1.0 0.0 0 true true abc $2^{20}$, soit $1\,048\,576$

]]> Bonne réponse : chaque objet est pris ou non, et les choix se
combinent : $2^{20}$ sous-ensembles, environ un million. C'est ce coût qui
rend le glouton attrayant malgré ses limites.

]]> $20^2$, soit $400$

]]> Erreur : le nombre de sous-ensembles n'est pas un carré mais une
puissance de deux.

]]> $2 \times 20$, soit $40$

]]> Erreur : deux choix par objet se multiplient, ils ne
s'additionnent pas.

]]> $20$, un par objet

]]> Erreur : un sous-ensemble peut contenir plusieurs objets ; il y
en a bien plus que d'objets.

]]>