UMLV 

Arbres recouvrants

Calcul d’un arbre de coût minimal

recouvrant un graphe connexe

Applications conception de réseaux

(téléphonique, électrique, d'intercommunication,...)
et étude de leur fonctionnement

Algorithmes
de Prim O(n2)
(adapté aux matrices d’adjacence)
de Kruskal O(a log a)
(adapté aux listes de successeurs
et graphes contenant peu d’arêtes)

601

UMLV 
Graphes non orientés

G=(S, A)
S sommets card S = n
A arêtes card A = a
A = {{s, t}, …} s ≠ t,… (pas de boucle)

a b
chemin : ({a,b}, {b,c}, {c,d}, {d,b}, {b,a})
chemin simple : ({a,b}, {b,c}, {c,d})
cycle simple : ({a,b}, {b,d}, {d,c}, {c,a})
c d

Chemin : c = ( {s 0,s1}, {s 1,s2}, …, {s k-1,sk } ) où les {s i-1,si} ∈ A

Chemin simple
les sommets intermédiaires n’apparaissent qu’une seule fois
Cycle simple
chemin simple avec s 0 = s k

602
 UMLV 
Sous-graphe
a b
Graphe non orienté G = (S, A)

c d b
Sous-graphe
G' ⊆ G : G' graphe (S', A')
avec S' ⊆ S et A' ⊆ A
c d
a b
Sous-graphe recouvrant
si S' = S
c d
a b
Arbre
graphe connexe sans cycle (simple)
Arbre recouvrant pour G
sous-graphe recouvrant qui est un arbre c d

603

UMLV 
Représentations

Matrice d'adjacence a b c d
a b
(symétrique) a 0 1 1 0
b 1 0 1 1
c 1 1 0 1
d 0 1 1 0 c d

Listes de successeurs
(redondantes)

a b c

b a c d

c a b d

d b c

604
 UMLV 
Problème ARCM

Graphe valué G = (S, A, v) avec valuation v : A → R

non-orienté et connexe

Coût d’un sous-graphe G’ = (S’, A’) : Σ (v(p,q) | (p,q) ∈ A’)

Problème : déterminer un ARCM, arbre recouvrant de coût

minimal pour G
coût = 14

6 b 4 b
1 c 1 c
f 5 5 f 5
a a
3 2 3 2
5 3 3

e d e d
6

605

UMLV 
Arbre recouvrant

Graphe non-orienté et connexe G = (S, A) card S = n

T = (S, B) arbre recouvrant pour G

Propriétés
T possède n-1 arêtes : card B = n-1
si {p, q} ∈ A-B alors H = (S, B + {u,v}) possède un cycle

b b
c
f c
card S = 6 f
a a
card B = 5
e d e d

606
 UMLV 
Coupure

Graphe valué G = (S, A, v) non-orienté et connexe

{P, Q} partition de S

Théorème
si {p, q} une arête de coût minimal entre P et Q
il existe un ARCM qui contient {p, q}

Q
6 b 4 b
1 c 1 c
f 5 5 f 5
P a a
3 2 3 2
5 3 3

e d e d
6

607

UMLV 

Preuve
Soit {p, q} une arête de coût minimal entre P et Q
p∈ P q∈Q
Soit T = (S, B) un ARCM pour G

si {p, q} ∈ B terminé
sinon
H = (S, B + {p, q}) contient un cycle
ce cycle contient {u, v} ∈ B, u ∈ P, v ∈ V
soit T’ = (S, B - {u, v} + {p, q})
T’ est un arbre recouvrant et
coût (T’) ≤ coût (T) ⇒ coût (T’) = coût (T)
donc {p, q} contenu dans l’ARCM T’

608
 UMLV 
Algorithmes gloutons

Traitement séquentiel des données

avec optimisation locale
Mais ne donne pas en général l'optimalité globale

c
1
a 2 b -2 Plus court chemin de a à c ?
2 d

Optimalité pour
- rendeur de monnaie
- codage de Huffman
- algorithme de Dijkstra
- ARCM par algorithmes
de Prim et de Kruskal

609

UMLV 
Méthode de Prim (1957)

Calcul d'un ARCM :

faire grossir un sous-arbre jusqu'au recouvrement du graphe

Exemple

6 b 4 6 b 4 6 b 4
1 c 1 c 1 c
f 5 5 f 5 5 f 5 5
a a a
3 2 3 2 3 2
5 3 5 3 5 3

e d e d e d
6 6 6

610
 UMLV 
Exemple (suite)

6 b 4 6 b 4 6 b 4
1 c 1 c 1 c
f 5 5 f 5 5 f 5 5
a a a
3 2 3 2 3 2
5 3 5 3 5 3

e d e d e d
6 6 6

b
1 c
ARCM f 5
coût = 14 a
3 2
3

e d
611

UMLV 
Algorithme de Prim

arbre PRIM( graphe ({1, 2, ..., n}, A, v) ) {

T ← {1} ;
B ← ∅;
tant que card T < n faire {
{p, q} ← arête de coût minimal
telle que p ∈ T et q ∉ T ;
T ← T + {q} ;
B ← B + {p, q} ;
}
retour (T, B) ;
}

Temps d’exécution : O(n²) au moyen de deux tables

indexées par les sommets

612
 UMLV 
Implémentation

Tables proche et coût pour trouver l’arête {p, q }

q∉T proche[q] = p ∈ T
ssi v(p, q) = min { v(p', q) | p' ∈ T }
q∉T coût[q] = v(proche[q], q)
q∈T coût[q] = +∞

6 b 4 a b c d e f
1 c proche
f 5 a a a a a
5
a
2
3
5 3 coût ∞ 1 5 3 5 5
e d
6

613

UMLV 
Une étape

6 b 4 a b c d e f
1 c proche
f 5 a a a a a
5
a
2
3
5 3 coût ∞ 1 5 3 5 5
e d
6
ajout de b et {a, b}
6 b 4
a b c d e f
1 c
f 5 5 proche a b a a a
a
3 2
3
5 coût ∞ ∞ 4 3 5 5
e d
6
Temps O( 1+card A(b) )
614
 UMLV 
Méthode de Kruskal (1956)

Calcul d'un ARCM :

réunir deux sous-arbres disjoints par une arête de coût minimal

Exemple

6 b 4 6 b 4 6 b 4
1 c 1 c 1 c
f 5 5 f 5 5 f 5 5
a a a
3 2 3 2 3 2
5 3 5 3 5 3

e d e d e d
6 6 6

615

UMLV 
Exemple (suite)

6 b 4 6 b 4 6 b 4
1 c 1 c 1 c
f 5 5 f 5 5 f 5 5
a a a
3 2 3 2 3 2
5 3 5 3 5 3

e d e d e d
6 6 6

b
1 c
ARCM f 5
coût = 14 a
3 2
3

e d
616
 UMLV 
Algorithme de Kruskal

arbre KRUSKAL( graphe ({1, 2, ..., n}, A, v) ) {

Partition ← { {1}, {2}, ..., {n} } ;
B ← ∅;
tant que card Partition > 1 faire {
{p, q} ← arête de coût minimal telle que
CLASSE(p) ≠ CLASSE(q) ;
B ← B + {p, q} ;
remplacer dans Partition CLASSE(p) et
CLASSE(q) par leur UNION ;
}
retour ( ({1, 2, ..., n}, B ) ;
}

Temps d’exécution : O(card A.log card A) avec gestion

efficace de la partition : type abstrait CLASSE-UNION

617

UMLV 
CLASSE//UNION
CLASSE UNION

Gestion d’une partition de {1, 2, …, n} avec les

opérations principales
CLASSE : numéro de classe d’un élément
UNION : union de classes disjointes

Implémentations possibles
1. table simple
2. arbres
3. idem + compression de chemins

Exemple n = 7
soit 1 ≡ 2 ; {1, 2} {3} {4} {5} {6} {7}
soit 5 ≡ 6 ; {1, 2} {3} {4} {5, 6} {7}
soit 3 ≡ 4 ; {1, 2} {3, 4} {5, 6} {7}
soit 1 ≡ 4 ; {1, 2, 3, 4} {5, 6} {7}
est-ce que 2 ≡ 3 ? oui car 2 et 3 dans la même classe

618
 UMLV 
Par table simple

1 2 3 4 5 6 7
CLASSE 1 1 3 3 5 5 7 représente {1,2} {3,4} {5,6} {7}

UNION des classes (disjointes) de p et q

{ x ← CLASSE [p] ; y ← CLASSE [q] ;
pour k ← 1 à n faire Temps
si CLASSE [k] = y alors CLASSE : constant
CLASSE [k] ← x ; UNION : O(n)
}

1 2 3 4 5 6 7
CLASSE 1 1 1 1 5 5 7 représente {1,2,3,4} {5,6} {7}

619

UMLV 
Par arbres
partition {1,2} {3,4} {5,6} {7}
CLASSE,TAILLE 1,2 3,2 5,2 7,1
arbres 1 3 5 7
1 2 3 4 5 6 7
2 4 6 P - 1 - 3 - 5 -

CLASSE(i ){
k ← i; Temps
tant que P[k] défini faire k ← P[k] ; CLASSE : O(n)
retour ( CLASSE[k] ) ; UNION : constant
}
partition {1,2,3,4} {5,6} {7}
CLASSE,TAILLE 1,4 5,2 7,1
arbres 1 5 7
1 2 3 4 5 6 7
2 3 6 P - 1 1 3 - 5 -

4
620
 UMLV 
Union des arbres
1
Éviter des arbres filiformes pour réduire
le temps de calcul de CLASSE(i ) 2

Stratégie pour UNION : toujours mettre n

le petit arbre enfant de la racine du gros

Temps
CLASSE : O(logn)
UNION : constant petite classe
grosse classe

Preuve
niveau( i ) augmente de 1 quand
union de P et Q, card P ≤ card Q et i ∈ P
i.e., quand la taille de la classe de i double au moins
Ceci ne peut arriver que log2n fois au plus

621

UMLV 
Compression de chemins

Idée : réduire le temps de calcul de CLASSE(i )

en « aplatissant » l'arbre à chaque calcul

1 1
2 3 2 3 5 7

4 5
4 6 8 9 0
6 7 8 après calcul
de CLASSE(7)
9 0

Temps de n calculs de CLASSE : O(n α (n)) 2

2 k fois
où α(n) est le plus petit entier k tel que n ≤ 2
Preuve [Aho, Hopcroft, Ullman, 1974]
622
 UMLV 
Ackermann
fonction A : N x N → N définie par
A(0, y) = 1 y ≥ 0
A(1, 0) = 2
A(x, 0) = x + 2 x≥ 2
A(x, y) = A(A(x-1, y), y-1) x, y ≥ 1

Propriétés
y = 0 A(x, 0) = x+2 x≥2

y=1 A(x, 1) = 2.x x≥1

car A(1,1) = A(A(0,1),0) = A(1,0) = 2
A(x,1) = A(A(x-1,1),0) = A(x-1,1)+2, . . .

y=2 A(x, 2) = 2x x≥1

car A(1,2) = A(A(0,2),1) = A(1,1) = 2
A(x,2) = A(A(x-1,2),1) = 2.A(x-1,2) , . . .

623

UMLV 

2
2
y=3 A(x,3) = 2 « tour de 2 en x exemplaires »

α (n) = plus petit k tel que n ≤ A(k, 3)

A(4,4) = « tour de 2 en 65536 exemplaires »

si n raisonnable, α(n) ≤ 4

624