Option Informatique Arbres couvrants minimaux

Option Informatique
Arbres couvrants minimaux
Corrig´e
30 novembre 2006
1 Petit rappel sur les graphes
Question 1 Soit G= (V, E)un graphe non orient´e `a nsommets. Justifier (rapidement) l’´equivalence des assertions suivantes :
1. Gest connexe et acyclique.
2. Gest connexe et comporte n−1arˆetes reliant des sommets distincts.
3. Gest acyclique et comporte n−1arˆetes reliant des sommets distincts.
4. Gest acyclique, mais ne le reste pas si on lui ajoute une arˆete.
5. Gest connexe, mais ne le reste pas si on lui enl`eve une arˆete.
6. deux sommets quelconques de Gont reli´es par un et un seul chemin ´el´ementaire.
– 4 ⇒3 : la graphe a au moins n−1 sommmets, sinon il n’est pas connexe, et il suffit d’ajouter une arˆete vers un sommet isol´e.
Il a au plus n−1 arˆetes, sinon on peut le consid´erer comme un graphe acyclique `a n−1 arˆetes auquel on a rajout´e karˆetes,
qui ne peut donc plus ˆetre acyclique par hypoth`ese.
– 3 ⇒2 : Consid´erons un graphe acyclique `a (n-1) arˆetes, arˆete par arˆete. Chaque nouvelle arˆete atteint un sommet qui n’a pas
´et´e atteint auparavant.
– 2 ⇒5 : Un argument de d´enombrement permet de conclure.
– 5 ⇒1 : par contrappos´ee.
– 1 ⇒4 : par contrappos´ee, si on enl`eve une arˆete (a, b) et que (a, b) restent reli´es, en remettant cette arˆete on obtient un cycle.
– 6 ⇔1 : par d´efinition.
2 Probl`eme de l’arbre couvrant
Question 2 Soit un graphe G= (V, E)acyclique, et e6∈ E. Montrer que G′= (V, E ∪ {e})est acyclique si et seulement si erelie
deux composantes connexes de G.
C’est l’´equivalence ¬5⇔ ¬1 qu’on tire ais´ement de la question 1.
3 Algorithme de Kruskal
Question 3 ´ Ecrire l’explosion d’un graphe en un ensemble de ses sous-graphes ´el´ementaires. ´ Evaluer sa complexit´e.
(explose : graphe →graphe list)
let explose g = map (function x →Sommets=[x] ; Aretes=[]) g.Sommets ; ;
Complexit´e O(|E|).
Question 4 ´ Ecrire une fonction fusion r´ealisant la fusion par l’arˆete ade deux graphes g1et g2d’une forˆet (liste de graphes), de
type graphe list →graphe →graphe →arete →graphe list.´ Evaluer sa complexit´e.

let rec fusion foret g1 g2 a =
let newforet = subtract foret [g1 ; g2]
in Sommets = union g1.Sommets g2.Sommets ; Aretes = a : :(union g1.Aretes g2.Aretes) : :newforet ; ;
Complexit´e O(|E1|+|E2|+|foret|).
Question 5 ´ Ecrire cherche_arbre, de type int →graphe list →graphe, qui `a tout ´el´ement xet `a toute forˆet fassocie le
graphe de fauquel appartient x.´ Evaluer sa complexit´e.
let rec cherche_arbre x = function
| [] →failwith "impossible"
| g : :q →
if (mem x g.Sommets)
then g
else cherche_arbre x q
; ;
Complexit´e O(|foret|).
Question 6 ´ Ecrire la recherche de la premi`ere arˆete d’une liste reliant deux arbres d’une forˆet
(cherche_areteK : graphe list →arete list →graphe * graphe * arete).
let rec cherche_areteK foret = function
| [] →failwith "Graphe non connexe"
| (Edge(x,y,_) as a) : :q →
let a_x = cherche_arbre x foret and a_y = cherche_arbre y foret in
if (a_x <> a_y)
then (a_x, a_y, a)
else cherche_areteK foret q
; ;
Complexit´e O(|E| × |foret|).
Question 7 En d´eduire une impl´ementation de la recherche d’arbre couvrant, et ´evaluer sa complexit´e.
(spanningtree : graphe →graphe).
let spanningtree g =
let rec aux ssgraphes aretes = match ssgraphes with
| [] →failwith "Boulette !"
| [spantree] →spantree
| _ →
let (g1, g2, a) = cherche_areteK ssgraphes aretes"
in aux (fusion ssgraphes g1 g2 a) aretes
in aux (explose g) g.Aretes ; ;
Complexit´e O(|E| × |V|2).
Question 8 ´ Ecrire une fonction tri_aretes de type arete list →arete list effectuant le tri d’une liste d’arˆetes par ordre de
poids croissant.
let tri_aretes l_aretes =
sort_sort
(fun (Edge(_,_,a)) (Edge(_,_,b)) →a <= b)
l_aretes
; ;
Complexit´e O(|v|log2(|v|)).
Question 9 ´ Ex´ecuter (sur un bout de papier) l’algorithme de Kruskal sur le graphe de la fig. 1 pour trouver un arbre couvrant de
poids minimal.
Voir fig. 1 et 2.
Question 10 A-t-on unicit´e de l’arbre couvrant de poids minimal ? Donner un arbre de mˆeme poids que celui de la question pr´ec´e-
dente, mais diff´erant d’une arˆete de celui que vous avez trouv´e.
Non, il suffit de remplacer l’arˆete (b, c) par l’arˆete (a, h).

Fig. 1 – Algorithme de Kruskal

Fig. 2 – Algorithme de Kruskal (suite)
Question 11 Prouver le lemme suivant :
Lemme 1 Si F1et F2sont deux sous-arbres couvrants et si α∈F1, α /∈F2, alors il existe
une arˆete β∈F2telle que F1\{α} ∪ {β}soit un sous-arbre couvrant.
Proof: Notons α=x, y.F1\{α}d´efinit deux composantes connexe simples (celle de x, celle de y). Dans le chemin simple reliant x
`a ydans F2, on peut choisir une arˆete βreliant un sommet de la composante connexe de x`a un sommet de celle de y. On constate
que βconvient. 
Question 12 En d´eduire une preuve de la validit´e de l’algorithme de Kruskal.
Il est clair que l’algorithme de Kruskal termine et fournit un sous-arbre couvrant. Prouvons qu’il est minimal.
Proof: Soit Fle r´esultat de l’algorithme et Uune solution minimale ayant le plus d’arˆetes communes avec F.Uet Font mˆeme
cardinal. Si U6=F, on prend α∈U\Fde telle sorte que v(α) soit minimal. Le lemme donne une arˆete βde F,U′=U\{α} ∪ {β}
est un arbre couvrant. Toutes les arˆetes de Umoins lourdes que αsont dans Fpar d´efinition de α. La construction de l’algorithme
donne alors : v(β)≤v(α) (sinon, αaurait ´et´e trait´ee avant βet aurait ´et´e accept´ee). Ainsi U′est-il encore minimal, et moins diff´erent
de Fque U, ce qui contredit sa d´efinition. 
Question 13 Modifier le programme de la question 7 pour qu’il donne un arbre couvrant de poids minimal. Comment ´evolue la
complexit´e ?
(spanningtree_Kruskal : graphe →graphe).
let spanningtree_Kruskal g =
...
in aux (explose g) (tri_aretes g.Aretes) ; ;
4 Minimalit´e
Question 14 Montrer que si les poids des arˆetes sont distincts deux `a deux, il n’existe qu’un seul arbre recouvrant minimal.

Soit deux arbres minimaux Fet F′diff´erant au moins sur l’arˆete α∈F\F′. Alors, d’apr`es la question 11, il existe une arˆete
βde F′qui relie les deux composantes connexes que reliait αdans F. Supposons sans perte de g´en´eralit´e v(α)< v(β). Alors
F′\{β} ∪ {alpha}est couvrant de poids strictement inf´erieur `a F′, contradiction.
Question 15 Soit H= (F, W )un arbre recouvrant minimal de G= (E, V ). Montrer qu’il existe a∈Wet b∈E\Wtelles que
(F, V ∪ {b}\{a})soit un arbre recouvrant de Gde poids minimal parmi les arbres recouvrants qui ne sont pas de poids minimal. On
supposera dans la fin de cette section que les arˆetes sont de poids deux `a deux distincts.
Il suffit de consid´erer pour bl’arˆete de poids minimal parmi celles qui relient les mˆemes composantes connexes que a. La question
11 permet de conclure.
Question 16 D´eduire de ce qui pr´ec`ede un algorithme construisant un arbre Gde poids minimal parmi les non minimaux. Complexit´e
de cet algorithme ?
On remarque qu’il s’agit simplement d’appliquer l’algorithme construisant l’arbre minimal dans le graphe ne comportant pas
l’arˆete consid´er´ee.
let non_minimal g a = (spanningtree_Kruskal Sommets = g.Sommets ;
Aretes = subtract g.Aretes a) ; ;
Question 17 A-t-on unicit´e de l’arbre de poids minimal parmi les non-minimaux ?
Oui, puisque les poids des arˆetes sont deux `a deux distincts, et d’apr`es la quesiton 14.
5 Algorithme de Prim
Question 18 Ex´ecuter (`a la main) l’algorithme de Prim sur le graphe de la fig. 1.
Voir la fig. 3.
Question 19 D´emontrer que l’algorithme de Prim renvoie bien un arbre couvrant minimal.
Il est clair que l’algorithme de Prim termine et fournit un sous-arbre couvrant. Prouvons qu’il est minimal.
Proof: Soit Uune solution minimale telle que le nombre d’´etapes de l’algorithme pendant lesquelles l’arbre en cours de construction
est un sous-arbre de Usoit maximale. Consid´erons pr´ecisement cette ´etape o`u l’algorithme rajoute `a F⊂Uune arˆete α=x, y qui
n’est pas dans U,xest dans le graphe d´efini par Fet non y. Il existe un chemin reliant x`a ydans U. Soit βla premi`ere arˆete
travers´ee par ce chemin, qui sort de F. On a v(α)≤v(β) par d´efinition de αdans l’algorithme. Rempla¸cons βpar αdans Upour
obtenir U′.U′est encore un arbre-couvrant minimal (supprimer βs´epare Uen deux composantes connexes que αr´eunit). Cela
contredit la d´efinition de U.
Question 20 Impl´ementer l’algorithme de Prim. On ´ecrira tout d’abord une fonction poids qui renvoie le poids d’un graphe pass´e
en param`etre, puis une fonction cherche_areteP qui prend en arguments une liste de sommets et une liste d’arˆetes, et qui renvoie
la premi`ere arˆete de la liste qui ne relie pas deux sommets cette premi`ere liste.
let poids g =
let rec aux = function
| [] →0
|(Edge(_,_,p)) : :q →p + aux q
in aux (g.Aretes)
; ;
let rec cherche_areteP sommets = function
| [] →failwith "Graphe non connexe"
| (Edge(x,y,_) as a) : :q →
let tmpx = mem x sommets and tmpy = mem y sommets in
if ((tmpx && (not tmpy)) || ((not tmpx) && tmpy))
then a
else cherche_areteP sommets q
; ;
let spanningtree_Prim g =
let rec aux sommets aretes spantree = function
| [] →Sommets = sommets ; Aretes = spantree
| reste →
let (Edge(x,y,_) as a) = cherche_areteP sommets aretes
in aux (union sommets [x ;y]) aretes (a : :spantree) (subtract reste [x ;y])
in let deb = g.Sommets.(0)
in aux [deb] (tri_aretes g.Aretes) [] (subtract (g.Sommets) [deb])
; ;