$course$/QCM de NSI/Terminale/Graphes Définition d'un graphe (sommets, arêtes), graphes orientés
et non orientés, pondérés, représentations (matrice
d'adjacence, liste d'adjacence), parcours en largeur
et en profondeur, plus court chemin, applications.

]]> Graphes — Q01 : Définition d'un graphe Qu'est-ce qu'un graphe en informatique ?

]]> Les graphes sont omniprésents : transport, réseaux
sociaux, web (pages reliées par hyperliens), réseaux
électriques, planification de tâches, recommandations.
Connaître les algorithmes de graphes est essentiel.

]]> 1.0 0.0 0 true true abc Un type d'arbre

]]> Erreur : c'est plutôt l'inverse. Un arbre est un
cas particulier de graphe (acyclique connexe).

]]> Une représentation visuelle de données numériques (camembert, histogramme)

]]> Erreur : ce serait un graphique. Un graphe en
informatique est une structure mathématique
différente.

]]> Un ensemble de sommets (ou nœuds) reliés par des arêtes (ou arcs si orientés)

]]> Bonne réponse : c'est la définition mathématique
standard. Un graphe modélise n'importe quelle
relation entre objets : réseau routier, réseau
social, dépendances de tâches, etc.

]]> Un dictionnaire trié

]]> Un dictionnaire est une
structure associant des
clés à des valeurs, sans
rapport avec un ensemble
de sommets reliés par des
arêtes.

]]> Graphes — Q02 : Graphe orienté Quelle est la différence entre un graphe orienté et
un graphe non orienté ?

]]> Cas typique : réseau routier (orienté si rues à sens
unique, non orienté si toutes en double sens). Le
web est orienté (un lien va d'une page à l'autre
sans symétrie).

]]> 1.0 0.0 0 true true abc Dans un graphe orienté, chaque arête a un sens (de A vers B), alors que dans un graphe non orienté, l'arête relie A et B sans préférence

]]> Bonne réponse : on parle d'arcs pour les
arêtes orientées. Exemple orienté : suivre
quelqu'un sur Twitter (asymétrique). Exemple non
orienté : amitié sur Facebook (symétrique).

]]> Un graphe orienté n'a pas de cycle

]]> Erreur : un graphe orienté peut avoir des
cycles. Sans cycle, on parle de DAG (graphe
orienté acyclique).

]]> Le graphe orienté contient plus de sommets

]]> Erreur : aucun rapport avec le nombre de sommets.

]]> Un graphe non orienté est plus rapide à parcourir

]]> Erreur : la vitesse de parcours dépend du nombre
de sommets et arêtes, pas de l'orientation.

]]> Graphes — Q03 : Graphe pondéré Qu'est-ce qu'un graphe pondéré ?

]]> Un graphe peut être à la fois orienté ET pondéré
(cas d'un GPS, d'un réseau de transport, etc.).

]]> 1.0 0.0 0 true true abc Un graphe avec beaucoup d'arêtes

]]> Erreur : c'est plutôt un graphe dense. Aucun
rapport avec « pondéré ».

]]> Un graphe partagé entre plusieurs utilisateurs

]]> Le partage entre
utilisateurs relève d'un
aspect logiciel sans
rapport avec la
pondération des arêtes.

]]> Un graphe trop lourd à stocker en mémoire

]]> Erreur : « pondéré » est un terme technique précis,
pas une métaphore.

]]> Un graphe où chaque arête porte un poids (valeur numérique), représentant par exemple une distance, un coût, un temps

]]> Bonne réponse : par exemple, un GPS représente
les routes par un graphe pondéré (poids = temps
de trajet). Les algorithmes de plus court chemin
(Dijkstra) exploitent ces poids.

]]> Graphes — Q04 : Matrice d'adjacence Une matrice d'adjacence d'un graphe à $n$ sommets est :

]]> Pour un graphe non orienté, la matrice est
symétrique ($M[i][j] = M[j][i]$). Pour un
graphe orienté, elle peut ne pas l'être.

]]> 1.0 0.0 0 true true abc Une matrice $n \times n$ où $M[i][j] = 1$ s'il existe une arête entre $i$ et $j$, sinon $0$ (ou le poids de l'arête si pondéré)

]]> Bonne réponse : c'est l'une des deux représentations
principales des graphes. Avantage : test
d'arête en $O(1)$. Inconvénient : consomme
$O(n^2)$ d'espace, même pour des graphes creux.

]]> Un tableau $1 \times n$ contenant les degrés

]]> Erreur : ce serait un tableau de degrés, pas une
matrice d'adjacence.

]]> Un arbre

]]> Un arbre est une
structure de données
spécifique, sans rapport
avec la représentation
d'un graphe par une
matrice.

]]> Un dictionnaire de listes

]]> Erreur : c'est plutôt une liste d'adjacence.

]]> Graphes — Q05 : Liste d'adjacence Une liste d'adjacence d'un graphe consiste à :

]]> Choix entre matrice et liste : matrice pour graphes
denses (peu de zéros) ou si on a besoin de
tester très souvent l'existence d'une arête. Liste
pour graphes creux (cas le plus fréquent en
pratique).

]]> 1.0 0.0 0 true true abc Stocker uniquement les sommets isolés

]]> Erreur : on stocke tous les sommets.

]]> Trier les sommets par degré

]]> Erreur : aucun tri requis.

]]> Numéroter les arêtes de $1$ à $m$

]]> Erreur : c'est plutôt une numérotation, pas une
liste d'adjacence.

]]> Stocker pour chaque sommet la liste de ses voisins

]]> Bonne réponse : pour le sommet $v$, on stocke la
liste de tous les sommets directement reliés à
lui. Plus efficace en mémoire que la matrice
d'adjacence pour les graphes creux
(peu d'arêtes par sommet). Espace : $O(n + m)$
avec $m$ arêtes.

]]> Graphes — Q06 : Parcours en largeur Le parcours en largeur d'un graphe :

]]> Application clé : trouver le plus court chemin
en nombre d'arêtes depuis un sommet de départ.
Aussi utilisé pour tester la connexité, calculer
les composantes connexes, etc.

]]> 1.0 0.0 0 true true abc Visite d'abord tous les voisins du sommet de départ, puis tous leurs voisins non visités, et ainsi de suite par niveaux

]]> Bonne réponse : c'est l'algorithme de référence
pour explorer un graphe en respectant la distance
en nombre d'arêtes. Implémentation : avec une
file (FIFO).

]]> Parcourt la branche la plus profonde d'abord

]]> Erreur : c'est le parcours en profondeur
(parcours en profondeur).

]]> Trie les sommets par valeur

]]> Erreur : aucun tri par valeur.

]]> Visite uniquement les feuilles

]]> Erreur : tous les sommets accessibles sont
visités.

]]> Graphes — Q07 : Parcours en profondeur Le parcours en profondeur d'un graphe :

]]> Mémo : largeur = file = FIFO ; profondeur =
pile = LIFO. Les deux parcours visitent tous les
sommets accessibles, mais dans un ordre différent.

]]> 1.0 0.0 0 true true abc Explore aussi loin que possible une branche avant de revenir en arrière pour explorer une autre

]]> Bonne réponse : implémentation typique avec une
pile (explicite ou implicite via la
récursivité). Le parcours en profondeur est
utile pour la détection de cycles, le tri
topologique, la recherche de composantes
fortement connexes, etc.

]]> Trie les sommets par profondeur

]]> Erreur : aucun tri par profondeur.

]]> Visite tous les voisins du sommet de départ avant d'aller plus loin

]]> Erreur : c'est le parcours en largeur.

]]> Calcule la longueur totale du graphe

]]> Erreur : aucune notion de longueur globale.

]]> Graphes — Q08 : Structure utilisée par parcours en largeur Pour implémenter un parcours en largeur, quelle structure
de données utilise-t-on naturellement ?

]]> En Python : from collections import deque ;
f = deque([depart]). Avec f.append(v) pour enfiler
et f.popleft() pour défiler, en $O(1)$ chacun.

]]> 1.0 0.0 0 true true abc Un dictionnaire

]]> Erreur : un dictionnaire n'a pas la sémantique
d'ordre nécessaire.

]]> Une pile

]]> Erreur : la pile correspond au parcours en
profondeur.

]]> Une file (FIFO)

]]> Bonne réponse : on enfile le sommet de départ,
puis tant que la file n'est pas vide on défile
un sommet, on visite, et on enfile ses voisins
non encore visités. C'est exactement le parcours en largeur.

]]> Aucune structure

]]> Erreur : il faut bien stocker les sommets en
attente.

]]> Graphes — Q09 : Structure utilisée par parcours en profondeur Le parcours en profondeur peut s'implémenter en utilisant :

]]> Récursivité = pile implicite. Itératif avec pile =
pile explicite. Les deux donnent le même résultat
(à l'ordre des voisins près). La version récursive
est souvent plus claire.

]]> 1.0 0.0 0 true true abc Une file uniquement

]]> Erreur : la file donne un parcours en largeur,
pas en profondeur.

]]> Un graphe imbriqué

]]> Cette description ne
correspond pas à une
structure standard
utilisée pour le
parcours d'un graphe.

]]> Un arbre binaire

]]> Erreur : un arbre est une structure différente,
pas l'outil de parcours.

]]> Une pile (explicite ou la pile d'appels via la récursivité)

]]> Bonne réponse : la récursivité utilise
implicitement la pile d'appels. La version
itérative utilise explicitement une pile (list
avec append et pop).

]]> Graphes — Q10 : Plus court chemin Pour trouver le plus court chemin (en nombre d'arêtes)
entre deux sommets dans un graphe non pondéré, on
utilise :

]]> Pour graphe pondéré à poids positifs : Dijkstra
($O((n + m) \log n)$). Pour graphe avec poids
négatifs : Bellman-Ford ($O(nm)$). parcours en largeur s'utilise
quand toutes les arêtes ont un poids identique
(typiquement, $1$).

]]> 1.0 0.0 0 true true abc Un tri topologique

]]> Erreur : c'est utile pour les DAG, pas pour les
plus courts chemins.

]]> Un parcours en largeur

]]> Bonne réponse : le parcours en largeur visite les sommets par
ordre croissant de distance (en arêtes) depuis
le sommet de départ. Le premier moment où on
atteint le sommet d'arrivée donne la distance
minimale.

]]> Un parcours en profondeur

]]> Erreur : parcours en profondeur ne donne pas le plus court chemin
en général. Il peut prendre une route longue.

]]> L'algorithme de Dijkstra

]]> Erreur : Dijkstra est pour les graphes
pondérés (poids positifs). Pour un graphe non
pondéré, parcours en largeur suffit.

]]> Graphes — Q11 : Degré d'un sommet Le degré d'un sommet dans un graphe non orienté
est :

]]> Théorème classique (Euler) : la somme des degrés
d'un graphe non orienté est $2m$ (deux fois le
nombre d'arêtes), car chaque arête contribue $1$ à
deux sommets.

]]> 1.0 0.0 0 true true abc Le nombre d'arêtes incidentes à ce sommet (i.e. le nombre de voisins).

]]> Bonne réponse : par exemple, dans le graphe
$\{(A, B), (A, C), (B, C)\}$, le sommet $A$ est
de degré $2$. Pour un graphe orienté, on
distingue le degré entrant et le degré
sortant.

]]> Le poids de l'arête la plus lourde incidente au sommet

]]> Le degré d'un sommet
est un nombre d'arêtes,
et non un poids. Le
poids n'intervient que
dans les graphes
pondérés, et n'est pas
lié à la notion de
degré.

]]> La distance jusqu'à la racine

]]> Erreur : il n'y a pas de racine dans un graphe
général. Confusion avec les arbres.

]]> Sa profondeur dans un parcours

]]> Erreur : la profondeur est une notion liée au
parcours, pas au sommet en soi.

]]> Graphes — Q12 : Cycle dans un graphe Un cycle dans un graphe est :

]]> Un arbre est un graphe connexe sans cycle. C'est
cette absence de cycle qui caractérise l'arbre par
rapport au graphe général.

]]> 1.0 0.0 0 true true abc Un sommet isolé

]]> Erreur : un sommet isolé n'a aucune arête. Ce
n'est pas un cycle.

]]> Une arête répétée

]]> Erreur : c'est un multi-graphe, notion
différente.

]]> Un sommet de degré pair

]]> Erreur : pas la définition d'un cycle.

]]> Une suite d'arêtes qui revient à son point de départ

]]> Bonne réponse : par exemple, le chemin
$A \to B \to C \to A$ forme un cycle. Détecter
les cycles est important : un graphe sans cycle
est appelé acyclique (DAG si orienté).

]]> Graphes — Q13 : Graphe connexe Un graphe non orienté est connexe quand :

]]> Le parcours en largeur ou parcours en profondeur depuis un sommet visite toute sa
composante connexe. Si on n'atteint pas tous les
sommets, le graphe n'est pas connexe.

]]> 1.0 0.0 0 true true abc Il est orienté

]]> Erreur : la connexité concerne les graphes
orientés ET non orientés.

]]> Il a beaucoup d'arêtes

]]> Erreur : la quantité ne suffit pas. C'est la
structure qui compte.

]]> Il existe un chemin entre toute paire de sommets

]]> Bonne réponse : on peut « atteindre » n'importe
quel sommet depuis n'importe quel autre. Si on
enlève cette propriété, on peut avoir plusieurs
composantes connexes (groupes isolés).

]]> Il a au moins $n$ arêtes

]]> Erreur : un graphe connexe à $n$ sommets a au
moins $n - 1$ arêtes (cas de l'arbre), mais
cela n'est pas suffisant.

]]> Graphes — Q14 : DAG Que signifie l'acronyme DAG ?

]]> Sur un DAG, le tri topologique est possible :
ranger les sommets dans un ordre tel que chaque
arête $u \to v$ va d'un sommet plus tôt vers un
sommet plus tard. Utilisé pour ordonnancer des
tâches respectant leurs dépendances.

]]> 1.0 0.0 0 true true abc Décomposition d'Algorithme par Graphe

]]> Erreur : sigle inventé.

]]> Distribution Aléatoire de Graphes

]]> Erreur : sigle inventé.

]]> Données Algorithmiques Génériques

]]> Erreur : sigle inventé.

]]> Directed Acyclic Graph (graphe orienté acyclique)

]]> Bonne réponse : un DAG est un graphe orienté
sans cycle. Très utile pour modéliser des
dépendances : tâches d'un projet, dépendances
de modules, généalogie, calculs, etc.

]]> Graphes — Q15 : Espace mémoire matrice vs liste Pour un graphe à $n = 1000$ sommets et $m = 5000$
arêtes, quelle représentation est la plus économe en
mémoire ?

]]> Densité d'un graphe : $d = m / \binom{n}{2}$. Pour
$d$ proche de $1$ (graphe dense), la matrice peut
être préférable. Pour $d$ proche de $0$ (creux), la
liste est meilleure.

]]> 1.0 0.0 0 true true abc La liste d'adjacence ($O(n + m) = 6000$ entrées)

]]> Bonne réponse : la liste d'adjacence consomme
de l'ordre du nombre d'arêtes plus le nombre de
sommets. Beaucoup mieux que la matrice quand le
graphe est creux ($m \ll n^2$), ce qui est
le cas en pratique pour beaucoup d'applications.

]]> La matrice d'adjacence ($O(n^2) = 10^6$ cases)

]]> Erreur : la matrice consomme bien plus que la
liste pour un graphe creux. La liste vaut mieux.

]]> Aucune différence

]]> Erreur : la différence est importante, surtout
pour les graphes creux.

]]> Cela dépend du langage de programmation

]]> Erreur : la complexité asymptotique est
indépendante du langage.

]]> Graphes — Q16 : Parcours en largeur et distance Avec un parcours en largeur depuis le sommet $s$, on calcule pour chaque
sommet $v$ atteignable :

]]> Au moment où parcours en largeur découvre un sommet, il peut
enregistrer (a) la distance, (b) le sommet
« parent » dans le parcours en largeur. Avec cela, on peut
reconstituer le chemin le plus court en arêtes.

]]> 1.0 0.0 0 true true abc Les sommets isolés

]]> Erreur : parcours en largeur visite seulement les sommets
accessibles depuis $s$.

]]> Tous les chemins possibles

]]> Erreur : trop d'information. parcours en largeur calcule
uniquement la distance minimale, pas tous les
chemins.

]]> Le poids minimal du chemin $s \to v$ (si pondéré)

]]> Erreur : parcours en largeur calcule la distance en nombre
d'arêtes, pas en poids. Pour les poids,
utiliser Dijkstra.

]]> Le nombre minimal d'arêtes du chemin $s \to v$

]]> Bonne réponse : c'est précisément ce que parcours en largeur
calcule. Très utile dans des graphes où toutes
les arêtes sont équivalentes (réseau social,
jeu de plateau, etc.).

]]> Graphes — Q17 : Application réseau social Sur un réseau social, on veut trouver tous les amis
« à distance $2$ » (amis d'amis) d'un utilisateur $u$.
Quel algorithme utiliser ?

]]> Cette technique est utilisée par LinkedIn, Facebook,
etc. La théorie des « six degrés de séparation »
affirme que dans le graphe social mondial, la
distance maximale est environ $6$.

]]> 1.0 0.0 0 true true abc Un parcours en largeur, en s'arrêtant à la profondeur $2$

]]> Bonne réponse : parcours en largeur avec une limite de
profondeur. À profondeur $0$ : $u$ ; à $1$ : ses
amis ; à $2$ : les amis des amis (sans compter
$u$ ni ses amis directs si on veut). Très
utilisé pour la recommandation d'amis.

]]> Un tri des amis par valeur d'identifiant

]]> Le tri d'une liste n'a
aucun rapport avec la
recherche d'amis à une
distance donnée dans un
réseau social.

]]> Un parcours en profondeur sans limite

]]> Erreur : parcours en profondeur n'organise pas les visites par
niveaux ; difficile d'extraire « distance $2$ ».

]]> Une recherche dichotomique

]]> Erreur : la dichotomie suppose une structure
ordonnée, ce qui n'est pas le cas d'un graphe
social.

]]> Graphes — Q18 : Liste d'adjacence en Python Comment représenter naturellement une liste d'adjacence
en Python ?

]]> Variante orientée objet : créer une classe Graphe
avec méthodes ajouter_sommet, ajouter_arete,
voisins, etc. Plus propre pour des projets
structurés. Mais en NSI, le dictionnaire suffit
souvent.

]]> 1.0 0.0 0 true true abc Comme un entier

]]> Erreur : un entier ne peut pas représenter une
structure complexe.

]]> Comme un tuple unique

]]> Erreur : trop limité pour stocker la structure.

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

]]> Erreur : difficile à manipuler et inefficace.

]]> Comme un dictionnaire où la clé est un sommet et la valeur est la liste de ses voisins

]]> Bonne réponse : par exemple,
g = {'A': ['B', 'C'], 'B': ['A'], 'C': ['A']}.
Très lisible et efficace. On accède aux voisins
en $O(1)$ via la clé.

]]> Graphes — Q19 : Code parcours en largeur Quelle fonction Python implémente correctement un parcours en largeur
depuis un sommet depart dans un graphe g (dictionnaire) ?

]]> L'ensemble visites est crucial : sans lui, sur un
graphe avec cycle, on bouclerait indéfiniment.
C'est l'une des erreurs classiques sur les graphes.

]]> 1.0 0.0 0 true true abc def bfs(g, depart): return [v for v in g]]]> Erreur : retourne tous les sommets sans
parcours. Ne respecte pas la connexité depuis
depart.

]]> def bfs(g, depart): visites = {depart} from collections import deque f = deque([depart]) while f: v = f.popleft() for w in g[v]: if w not in visites: visites.add(w) f.append(w) return visites]]> Bonne réponse : structure standard. On garde une
ensemble visites pour éviter les boucles
infinies sur les graphes cycliques. La file
impose le parcours en largeur.

]]> def bfs(g, depart): return g[depart]]]> Erreur : retourne uniquement les voisins
directs, pas le parcours complet.

]]> def bfs(g, depart): return sorted(g.keys())]]> Erreur : trie les clés sans parcourir le graphe.

]]> Graphes — Q20 : Arbre comme cas particulier Un arbre (au sens informatique) est un cas
particulier de :

]]> Tout arbre à $n$ sommets a exactement $n - 1$
arêtes. Si l'on a $n$ sommets, $n - 1$ arêtes et la
connexité, alors c'est un arbre (et donc sans
cycle). Triple caractérisation.

]]> 1.0 0.0 0 true true abc Graphe : c'est un graphe non orienté, connexe et acyclique

]]> Bonne réponse : tous les concepts d'arbre
(racine, hauteur, parcours) sont applicables aux
graphes plus généralement, mais l'arbre garantit
des propriétés (chemin unique entre deux
sommets) qui simplifient les algorithmes.

]]> Tableau

]]> Erreur : un tableau est linéaire, un arbre
hiérarchique.

]]> File

]]> Erreur : file et arbre sont distincts.

]]> Pile

]]> Erreur : pile et arbre sont des structures
totalement différentes.

]]> Graphes — Q21 : Algorithme de Dijkstra L'algorithme de Dijkstra calcule les plus courts
chemins depuis une source dans un graphe pondéré. Quelle
est sa contrainte sur les poids ?

]]> Dijkstra s'implémente classiquement avec une file
de priorité (tas), donnant une complexité
$O((n + m) \log n)$. Très utilisé dans les GPS,
les protocoles de routage et les jeux vidéo
(recherche de chemin pour les déplacements de
personnages).

]]> 1.0 0.0 0 true true abc Les poids doivent être positifs ou nuls (pas de poids négatifs)

]]> Bonne réponse : avec des poids négatifs,
l'invariant glouton de Dijkstra ne tient plus.
Pour les poids négatifs, utiliser Bellman-Ford.

]]> Les poids doivent être entiers

]]> Erreur : Dijkstra fonctionne avec des poids
réels.

]]> Les poids doivent être triés à l'avance

]]> Erreur : aucun tri préalable requis. Dijkstra
gère lui-même la priorité via une file de
priorité.

]]> Les poids doivent être tous identiques

]]> Erreur : si tous les poids sont identiques, parcours en largeur
suffit. Dijkstra est conçu pour des poids
variables.

]]> Graphes — Q22 : Tri topologique Un tri topologique d'un DAG :

]]> Algorithmes : algorithme de Kahn (par degré
entrant) ou parcours en profondeur avec post-ordre inversé. Application
classique : compilation, ordonnancement de
makefiles, calcul de tableaux d'événements.

]]> 1.0 0.0 0 true true abc Range les sommets dans un ordre tel que pour chaque arête $u \to v$, $u$ apparaît avant $v$

]]> Bonne réponse : c'est un ordre respectant les
dépendances. Très utile pour ordonnancer des
tâches : faire $u$ avant $v$ si $u$ est requis
pour $v$. Plusieurs ordres valides sont possibles
en général.

]]> Trie les sommets par valeur croissante

]]> Erreur : pas un tri par valeur. C'est un tri
structurel basé sur les dépendances.

]]> Élimine les cycles

]]> Erreur : un tri topologique requiert un graphe
déjà acyclique (DAG). On ne supprime pas de
cycles.

]]> Trie les sommets par degré

]]> Erreur : pas de tri par degré.

]]> Graphes — Q23 : Composantes connexes Pour calculer les composantes connexes d'un graphe
non orienté, on peut :

]]> Cette technique fonctionne aussi avec une
structure d'Union-Find (très efficace pour
les graphes statiques). En NSI, le parcours en largeur/parcours en profondeur suffit
largement.

]]> 1.0 0.0 0 true true abc Utiliser une recherche dichotomique

]]> Erreur : pas adapté aux graphes non ordonnés.

]]> Lancer un parcours en largeur (ou parcours en profondeur) depuis chaque sommet non encore visité ; chaque parcours visite une composante

]]> Bonne réponse : algorithme classique en $O(n + m)$.
Tant qu'il reste des sommets non visités, on en
choisit un et on lance un parcours qui marque
tous les sommets de sa composante. On compte le
nombre de parcours lancés.

]]> Compter les sommets

]]> Erreur : ça donne $n$, pas le nombre de
composantes.

]]> Trier les sommets par numéro

]]> Le tri des sommets ne
révèle pas leur
appartenance à une
composante connexe : il
faut suivre les arêtes
du graphe pour
déterminer cette
appartenance.

]]> Graphes — Q24 : Arbre couvrant Un arbre couvrant d'un graphe connexe est :

]]> Application classique de l'arbre couvrant minimal :
réseaux électriques (minimiser la longueur de
câble), réseaux informatiques, plans
d'urbanisation. Algorithmes : Kruskal (glouton sur
les arêtes), Prim (glouton sur les sommets).

]]> 1.0 0.0 0 true true abc Un sous-graphe qui contient toutes les arêtes

]]> Erreur : ce serait le graphe lui-même.

]]> Une racine du graphe

]]> Erreur : un graphe général n'a pas de racine.

]]> Un cycle qui passe par tous les sommets

]]> Erreur : c'est un cycle hamiltonien, pas un
arbre couvrant.

]]> Un sous-graphe qui contient tous les sommets et forme un arbre (connexe, sans cycle)

]]> Bonne réponse : un arbre couvrant contient $n$
sommets et $n - 1$ arêtes choisies parmi celles
du graphe initial. Quand le graphe est pondéré,
on peut chercher l'arbre couvrant minimal
(Kruskal, Prim) : minimise la somme des poids.

]]> Graphes — Q25 : Choisir le bon algorithme Vous voulez calculer le chemin le plus court entre deux
villes sur un réseau routier (les routes ont des
longueurs en kilomètres positives). Quel algorithme
choisir ?

]]> Récapitulatif algorithmes plus courts chemins :
parcours en largeur (non pondéré), Dijkstra (poids positifs),
Bellman-Ford (poids négatifs sans cycle négatif),
Floyd-Warshall (toutes paires de sommets en
$O(n^3)$).

]]> 1.0 0.0 0 true true abc parcours en profondeur

]]> Erreur : parcours en profondeur ne calcule pas les plus courts
chemins.

]]> parcours en largeur

]]> Erreur : parcours en largeur minimise le nombre d'arêtes, pas
la somme des poids. Le résultat ignorerait
les longueurs.

]]> Tri topologique

]]> Erreur : utile pour les DAG, pas pour les
plus courts chemins en général.

]]> L'algorithme de Dijkstra (les poids sont positifs)

]]> Bonne réponse : Dijkstra est exactement conçu
pour ce cas. Pour des graphes très grands, on
utilise des variantes optimisées (A*, Dijkstra
bidirectionnel, contractions).

]]> Graphes — Q26 : Conversion entre représentations Soit le graphe non orienté représenté par la
liste d'adjacence
g = {'A': ['B', 'C'], 'B': ['A', 'C'], 'C': ['A', 'B']}.
Quelle est la matrice d'adjacence correspondante
avec l'ordre des sommets [A, B, C] ?

]]> Pour un graphe non orienté, la matrice
d'adjacence est toujours symétrique. Pour un
graphe orienté, ce n'est pas nécessairement le
cas. Les deux représentations sont équivalentes
en information ; le choix dépend des opérations
les plus fréquentes (test d'arête en O(1) avec
la matrice ; énumération des voisins efficace
avec la liste).

]]> 1.0 0.0 0 true true abc [[0, 1, 0], [1, 0, 1], [0, 1, 0]]]]> Erreur : cette matrice correspondrait à un
graphe en chaîne A - B - C, où A et C
ne sont pas directement reliés. Or le graphe
donné est complet : A et C sont voisins.

]]> [[0, 1, 1], [1, 0, 1], [1, 1, 0]]]]> Bonne réponse : chaque sommet est relié à
chacun des deux autres (graphe complet $K_3$).
La diagonale est nulle (pas de boucle), et la
matrice est symétrique (graphe non orienté).
Toutes les autres cases valent $1$ car les
arêtes existent dans tous les sens.

]]> [[0, 0, 0], [0, 0, 0], [0, 0, 0]]]]> Erreur : ce serait un graphe sans aucune
arête. Or le graphe possède bien des arêtes
(chaque sommet a des voisins dans la liste
d'adjacence).

]]> [[1, 1, 1], [1, 1, 1], [1, 1, 1]]]]> Erreur : la diagonale ne doit pas être à $1$
car aucun sommet n'a de boucle sur lui-même
(par exemple, g['A'] ne contient pas 'A').

]]> Graphes — Q27 : Théorème des poignées de mains Dans un graphe non orienté, quelle relation
relie la somme $S$ des degrés de tous les
sommets et le nombre $m$ d'arêtes ?

]]> Conséquence amusante : dans un groupe de
personnes, le nombre de personnes ayant serré
la main à un nombre impair d'autres
personnes est forcément pair. C'est l'une des
premières applications de la théorie des
graphes (Euler, $1736$).

]]> 1.0 0.0 0 true true abc $S = n$ (nombre de sommets)

]]> Erreur : la somme des degrés dépend du
nombre d'arêtes, pas du nombre de
sommets. Un graphe avec beaucoup de sommets
mais peu d'arêtes a une somme des degrés
faible.

]]> $S = m$

]]> Erreur : oublie le double comptage. Chaque
arête participe à deux degrés (un par
extrémité), pas un seul.

]]> $S = m^2$

]]> Erreur : aucune raison d'avoir une relation
quadratique. La relation est linéaire : $S$
dépend de $m$ par un facteur multiplicatif
de $2$.

]]> $S = 2m$

]]> Bonne réponse : c'est le théorème des poignées
de mains. Chaque arête contribue $1$ au degré
de chacun de ses deux extrémités, donc compte
deux fois dans la somme des degrés. D'où
$S = 2m$. Conséquence directe : la somme des
degrés est toujours paire, et le nombre
de sommets de degré impair est aussi pair.

]]> Graphes — Q28 : Trace d'un parcours en largeur On effectue un parcours en largeur du graphe
g = {'A': ['B', 'C'], 'B': ['A', 'D'], 'C': ['A', 'D'], 'D': ['B', 'C', 'E'], 'E': ['D']}
en partant de 'A', en visitant les voisins
dans l'ordre où ils apparaissent dans la liste.
Dans quel ordre les sommets sont-ils visités ?

]]> Le parcours en largeur visite les sommets dans
l'ordre croissant de leur distance (en arêtes)
au sommet de départ. Niveau $0$ : $A$. Niveau
$1$ : $B$, $C$. Niveau $2$ : $D$. Niveau $3$ :
$E$. C'est exactement ce qui justifie l'usage
du parcours en largeur pour calculer les plus
courts chemins en nombre d'arêtes.

]]> 1.0 0.0 0 true true abc A, B, C, D, E

]]> Bonne réponse : on commence par enfiler A,
puis on défile A et on enfile ses voisins
B et C. On défile B, on enfile D
(A est déjà visité). On défile C (ses
voisins A et D sont déjà visités ou
enfilés). On défile D, on enfile E. On
défile E. Ordre de visite : A, B, C, D, E.

]]> A, B, D, E, C

]]> Erreur : c'est un parcours en profondeur
(qui suit une branche en suivant les
voisins). Le parcours en largeur, lui,
visite les sommets par niveaux croissants
de distance, pas en plongeant.

]]> A, C, B, D, E

]]> Erreur : on visite les voisins dans l'ordre
où ils apparaissent dans la liste. Pour A,
c'est B puis C. Donc B est visité
avant C, pas l'inverse.

]]> A, B, C, E, D

]]> Erreur : on visite D avant E car D est
enfilé en premier (par B), et E n'est
enfilé que plus tard (quand on visite D).
L'ordre est donc D avant E.

]]> Graphes — Q29 : Trace de l'algorithme de Dijkstra On considère le graphe pondéré suivant
(arêtes non orientées) :
A-B (4), A-C (2), B-C (1), B-D (5),
C-D (8), C-E (10), D-E (2). On lance
Dijkstra depuis le sommet A. Quelle est la
distance minimale de A à E ?

]]> Méthode systématique : tenir un tableau
dist[v] pour chaque sommet. Tant qu'il
reste des sommets non traités, extraire le
sommet de plus petite distance, et relâcher
(mettre à jour) ses voisins :
dist[w] = min(dist[w], dist[v] + poids(v,w)).
Cet algorithme est glouton : on traite
définitivement un sommet quand on l'extrait.
Cela exige des poids positifs ; sinon,
utiliser Bellman-Ford.

]]> 1.0 0.0 0 true true abc $14$ (en passant par A-B-D-E)

]]> Erreur : ce chemin pèse $4 + 5 + 2 = 11$,
pas $14$. Et il n'est pas optimal :
passer d'abord par C permet d'atteindre
B à coût $3$ (au lieu de $4$), ce qui
réduit ensuite le chemin total.

]]> $12$ (en passant directement par C-E)

]]> Erreur : c'est une distance valide
(chemin A → C → E), mais ce n'est pas
la plus courte. Le chemin
A → C → B → D → E totalise
$2 + 1 + 5 + 2 = 10$, ce qui est moins.
Dijkstra trouve toujours le minimum.

]]> $11$

]]> Erreur : aucun chemin de A à E n'a
ce poids. Refaire le calcul en
considérant les chemins possibles :
A → C → E pèse $12$, A → B → D → E
pèse $4 + 5 + 2 = 11$, et
A → C → B → D → E pèse
$2 + 1 + 5 + 2 = 10$. C'est ce dernier
qui est minimal.

]]> $10$

]]> Bonne réponse : on trace les distances
successivement. Étape 1 : on extrait
A ($0$), on met à jour B=4, C=2.
Étape 2 : on extrait C (le plus
petit, $2$), on met à jour
B = min(4, 2+1) = 3, D = 2+8 = 10,
E = 2+10 = 12. Étape 3 : on extrait
B ($3$), on met à jour
D = min(10, 3+5) = 8. Étape 4 : on
extrait D ($8$), on met à jour
E = min(12, 8+2) = 10. Étape 5 : on
extrait E ($10$), parcours terminé.
Le chemin optimal est donc
A → C → B → D → E de poids total
$2 + 1 + 5 + 2 = 10$.

]]> Graphes — Q30 : Code du parcours en profondeur récursif Quel code Python implémente correctement un
parcours en profondeur récursif d'un graphe g
(dictionnaire d'adjacence) à partir d'un
sommet depart ?

]]> Pour transformer ce parcours en profondeur
récursif en parcours en profondeur itératif
avec pile explicite, on remplace la
récursion par une pile que l'on dépile et
empile manuellement. Cela permet de mieux
contrôler la consommation de pile et
d'éviter RecursionError sur les très
grands graphes.

]]> 1.0 0.0 0 true true abc def parcours_profondeur(g, depart, visites=None): if visites is None: visites = set() visites.add(depart) for voisin in g[depart]: if voisin not in visites: parcours_profondeur(g, voisin, visites) return visites]]> Bonne réponse : on marque le sommet
courant, puis on appelle récursivement
la fonction sur chaque voisin non encore
visité. La récursivité utilise
implicitement la pile d'appels, ce qui
réalise naturellement le LIFO du
parcours en profondeur. L'astuce
visites=None puis création d'un
ensemble dans la fonction évite le piège
du paramètre par défaut mutable, qui
serait partagé entre les appels
successifs.

]]> def parcours_profondeur(g, depart): for voisin in g[depart]: parcours_profondeur(g, voisin)]]> Erreur : aucune trace des sommets
visités. Sur un graphe avec un cycle, la
fonction boucle indéfiniment et finit
par lever RecursionError. La
mémorisation des sommets déjà visités
est essentielle.

]]> def parcours_profondeur(g, depart): return list(g[depart])]]> Erreur : ce code retourne uniquement les
voisins directs du sommet de départ,
pas le parcours complet. Il manque la
descente récursive dans les voisins.

]]> def parcours_profondeur(g, depart, visites={}): visites[depart] = True for voisin in g[depart]: if voisin not in visites: parcours_profondeur(g, voisin, visites) return visites]]> Piège classique du paramètre par défaut
mutable : le dictionnaire visites = {}
est créé une seule fois, à la
définition de la fonction. Tous les
appels successifs à
parcours_profondeur(g, ...) partagent
alors le même dictionnaire, ce qui
conduit à un bug subtil : un nouveau
parcours conserve les sommets visités
d'un parcours précédent.

]]> Graphes — Q31 : Détection de cycle dans un graphe orienté Comment détecter la présence d'un cycle
dans un graphe orienté à l'aide d'un
parcours en profondeur ?

]]> Application directe : un graphe orienté est
un DAG si et seulement s'il ne contient
aucun cycle. La détection de cycles est
donc l'algorithme préliminaire à tout tri
topologique. Sur un graphe non orienté,
la détection est plus simple : il suffit de
vérifier qu'au cours du parcours en
profondeur, on ne rencontre pas un voisin
déjà visité (autre que le parent immédiat).

]]> 1.0 0.0 0 true true abc On marque chaque sommet avec trois états :
non visité, en cours de visite
(sur la pile d'appels actuelle), et
terminé. Si pendant le parcours, on
rencontre une arête vers un sommet « en
cours de visite », on a détecté un cycle

]]> Bonne réponse : c'est l'algorithme
standard, dit des « trois couleurs »
(blanc, gris, noir). Le sommet « gris »
est en cours de visite : si on retombe
dessus, c'est qu'on a fait un cycle.
Sans la distinction « en cours / terminé »,
on confondrait un cycle avec une simple
réutilisation d'un sommet déjà exploré
dans une autre branche.

]]> On compte simplement le nombre d'arêtes :
s'il dépasse $n - 1$, il y a un cycle

]]> Erreur : cette propriété est vraie pour
les graphes non orientés connexes (un
arbre couvrant a exactement $n - 1$
arêtes), mais pas pour les graphes
orientés en général. Un graphe orienté
peut avoir beaucoup plus d'arêtes sans
cycle (DAG dense).

]]> Il est impossible de détecter un cycle en
temps polynomial

]]> Erreur : la détection de cycle se fait en
$O(n + m)$ avec un parcours en
profondeur. C'est l'un des algorithmes
les plus efficaces sur les graphes.

]]> On regarde si la matrice d'adjacence est
symétrique

]]> Erreur : la symétrie de la matrice
d'adjacence indique que le graphe est
non orienté (toute arête a son
retour), pas qu'il y a un cycle.

]]> Graphes — Q32 : Algorithme de Kahn pour le tri topologique Quel est le principe de l'algorithme de
Kahn pour calculer un tri topologique d'un
DAG ?

]]> Application : compilation d'un projet (les
modules dépendent les uns des autres),
ordonnancement de tâches (certaines
doivent précéder d'autres), résolution de
formules dans un tableur (l'ordre de
recalcul respecte les dépendances entre
cellules). Si le graphe contient un cycle,
l'algorithme de Kahn s'arrête prématurément
et révèle l'impossibilité d'un tri
topologique.

]]> 1.0 0.0 0 true true abc On effectue un parcours en largeur depuis
le premier sommet

]]> Erreur : le parcours en largeur
standard parcourt par distance, pas par
dépendances. Il existe une variante du
parcours en profondeur (post-ordre
inversé) qui donne aussi un tri
topologique, mais ce n'est pas l'idée
de Kahn.

]]> On trie les sommets par ordre alphabétique
de leur identifiant

]]> Erreur : un tri alphabétique ne respecte
pas les dépendances. Le tri topologique
doit garantir que pour chaque arête
u → v, u apparaît avant v dans
l'ordre, ce que l'ordre alphabétique ne
fait absolument pas en général.

]]> On retire répétitivement les sommets de
degré entrant nul (qui ne dépendent
de rien) ; à chaque retrait, on les
ajoute à la liste de sortie et on
décrémente le degré entrant de leurs
voisins. On continue jusqu'à ce qu'il ne
reste plus aucun sommet

]]> Bonne réponse : c'est un algorithme
glouton très intuitif. À chaque étape,
on traite un sommet « libre de toute
dépendance ». Si à un moment plus aucun
sommet n'est de degré entrant nul mais
qu'il en reste, c'est qu'il y a un
cycle (le graphe n'est pas un DAG).
Implémentation : maintenir une file (ou
ensemble) des sommets de degré entrant
nul, et la mettre à jour à chaque retrait.
Complexité : $O(n + m)$.

]]> On calcule la matrice d'adjacence puis on
cherche les valeurs propres

]]> Erreur : aucun rapport. Le calcul de
valeurs propres est une opération
d'algèbre linéaire, sans lien avec le
tri topologique des graphes.

]]>