Algorithmes dynamiques pour les graphes plongés sur des surfaces

Master 2 - Spécialité informatique fondamentale.
Algorithmes dynamiques pour les
graphes plongés sur des surfaces
10 Juin 2013
Vincent DESPRE
encadré par
Francis LAZARUS
Table des matières
1 Cadre de l’étude
1.1 Graphes plongés . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.1.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.1.2 Les différents types de cycles . . . . . . . . . . . . . . . .
1.1.3 Décomposition arbre-coarbre . . . . . . . . . . . . . . . .
1.2 Les algorithmes statiques . . . . . . . . . . . . . . . . . . . . . .
1.2.1 Applications directes de la décomposition arbre-coarbre .
1.2.2 Condition des 3 chemins (3-path condition) et découpages
1.3 Algorithmes dynamiques ou utilisant des méthodes dynamiques .
1.3.1 Plus courts chemins à sources multiples . . . . . . . . . .
1.3.2 Base d’homotopie dynamique . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2
2
2
3
4
5
5
6
6
6
7
2 Étude des arbres dynamiques
2.1 Cadre . . . . . . . . . . . . . .
2.2 Splay-Trees . . . . . . . . . . .
2.2.1 Idée . . . . . . . . . . .
2.2.2 Opérations . . . . . . .
2.2.3 Application aux link-cut
2.3 Euler-Tour Trees . . . . . . . .
2.3.1 Opérations . . . . . . .
2.3.2 Fonctionnement . . . . .
2.4 Top-Trees . . . . . . . . . . . .
2.4.1 Fonctionnement . . . . .
2.4.2 Opérations . . . . . . .
2.4.3 Défauts . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
8
8
8
8
9
9
9
9
10
10
10
11
11
3 Du statique vers le dynamique
3.1 Cadre de l’étude, premières remarques . . . . . . . . . .
3.1.1 Problème étudié . . . . . . . . . . . . . . . . . .
3.1.2 Remarques préalables . . . . . . . . . . . . . . .
3.2 Première approche . . . . . . . . . . . . . . . . . . . . .
3.2.1 Idée . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.2 Plus courts chemins pour toutes les paires . . . .
3.2.3 Plus courts chemins dynamiques de base fixée . .
3.3 Nombre de pivots . . . . . . . . . . . . . . . . . . . . . .
3.3.1 Pour un arbre de plus courts chemins donné . . .
3.3.2 Sur l’ensemble des arbres de plus courts chemins
3.3.3 Résultat . . . . . . . . . . . . . . . . . . . . . . .
3.3.4 Arbres couvrants . . . . . . . . . . . . . . . . . .
3.4 Autres approches . . . . . . . . . . . . . . . . . . . . . .
3.4.1 Autres algorithmes envisagés . . . . . . . . . . .
3.4.2 Division d’un plus court chemin . . . . . . . . .
3.4.3 Utilisation . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
11
11
11
12
12
12
13
13
14
14
14
16
16
16
16
17
19
. . .
. . .
. . .
. . .
trees
. . .
. . .
. . .
. . .
. . .
. . .
. . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4 Conclusion
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
19
1
Résumé
Le rapport de stage suivant décrit le travail effectué pour un stage de M2 réalisé dans l’équipe
AGPIG du laboratoire Gipsa-Lab de l’université de Grenoble encadré par Francis Lazarus. Le sujet du
stage était le suivant : Aspects dynamiques de l’algorithmique des surfaces combinatoires.
Le premier chapitre présente le cadre de l’étude. On s’intéresse à des graphes plongés sur des surfaces.
Après avoir décrit plus précisément ce cadre, on réalise un petit état des lieux des algorithmes connus à
l’heure actuelle dans le domaine. Ensuite le deuxième chapitre décrit la structure de donnée qui permet
de traiter de nombreux algorithmes dynamiques : les arbres dynamiques. Enfin la dernière section
décrit le travail qui a été effectué à partir de cet état des lieux. L’idée de base était d’appliquer une
méthode similaire à celle d’Eppstein décrite dans l’article : Dynamic generators of topologically
embedded graphs [8] à d’autres algorithmes décrits au premier chapitre. Il utilise la structure de
données du deuxième chapitre qui semble incontournable pour l’étude des problèmes dynamiques. Les
résultats de la dernière section sont plutôt négatifs pour une approche classique de la complexité dans
le pire des cas. Plusieurs contre-exemples permettent de s’assurer de la difficulté du problème.
1
Cadre de l’étude
1.1
1.1.1
Graphes plongés
Principe
Notations On note G = (V, E) un graphe constitué d’un ensemble de sommets V et d’un ensemble
d’arêtes E. On notera n le nombre de sommets et m le nombre d’arêtes du graphe. Les arêtes sont des
couples de sommets, on dispose donc d’une orientation correspondante. Beaucoup de résultats nécessitent
que le graphe soit non-orienté, ce qui signifie que E doit contenir les opposés de toutes ses arêtes. Sauf
mention contraire, les graphes mentionnés seront pondérés, c’est à dire qu’il existera une fonction poids
w : E → R∗+ strictement positive.
Plongement Étant donné un tel graphe G, on dit qu’il y a un plongement de G dans une surface S si
on peut dessiner le graphe G sur la surface S. Plus précisément, on veut que chaque sommet de G soit
identifié à un point de S et qu’il existe des fonctions continues Puv : [0; 1] → S pour chaque arête uv ∈ E
telles que : Puv (0) = u et Puv (1) = v. On demande de plus que tous les Puv (]0; 1[) soient disjoints et ne
contiennent pas de point de S identifié à un sommet de V [17].
Classification des surfaces On parle de variétés compactes de dimension 2. Pour les études qui nous
intéressent le plan a des propriétés comparables à S 2 , on parlera donc du plan bien qu’il ne soit pas
compact. On a, pour commencer, 2 grandes catégories de surfaces. Celles qui disposent d’une orientation
continue sur l’ensemble de la surface (on rappel qu’une orientation est une fonction qui, à chaque point
x ∈ S, associe un couple de vecteurs unitaires orthogonaux de l’espace tangent à S en x) sont dites
orientables. Il existe des surfaces qui n’ont pas cette propriété, comme le ruban de Möbius, elles sont alors
dites non-orientables. Ensuite, le théorème de classification des surfaces nous dit qu’une surface est définie
à homéomorphisme près par son orientabilité et un nombre entier qu’on appelle le genre de la surface [19].
Ainsi, le plan est de genre 0, le tore de genre 1, le double-tore de genre 2, etc.
Outils correspondants La première information qu’on obtient quand on a un plongement pour un
graphe G donné, est une relation entre son nombre de sommets n, son nombre d’arêtes m et son nombre
de face f :
Définition 1 (Caractéristique d’Euler). Pour un graphe G plongé dans une surface S de genre g et avec
les notations décrites précédemment, on définit la caractéristique d’Euler χ par :
χ(g) = n − m + f
2
où χ(g) = 2 − 2g si S est orientable et χ(g) = 2 − g sinon.
Vient ensuite le problème du genre du graphe qui est le plus petit entier g tel que G se plonge dans une
surface de genre g. Le problème de décision correspondant est NP-complet [17]. On va donc s’intéresser à
des plongements donnés ayant la propriété suivante :
Définition 2 (Plongement cellulaire). On dit qu’un plongement est cellulaire si la surface privée de
l’image du graphe est une union de disques.
Surfaces combinatoires On va alors considérer le problème d’un autre point de vue. En partant du
graphe, on va construire une surface dans laquelle le graphe est naturellement plongé cellulairement [17].
On divise chaque arête en demi-arête et on attribue chaque demi-arête au sommet auquel elle est rattachée.
Chaque sommet détient alors un certain nombre de demi-arêtes.
Définition 3 (Système de rotations). Pour chaque sommet, on va définir une permutation circulaire
de l’ensemble des demi-arêtes qu’il possède. La donnée de toutes ces permutations pour l’ensemble des
sommets du graphe est appelé système de rotation.
On définit alors une surface en considérant les arêtes comme des bandes et en les recollant tout en
respectant le système de rotation. La surface obtenue dispose par construction d’un plongement cellulaire
du graphe de départ. Il est facile de savoir si une surface ainsi construite est orientable ou non et on
obtient le genre de la surface grâce à la caractéristique d’Euler. Réciproquement, un plongement cellulaire
explicite d’un graphe peut se traduire en terme de surface combinatoire en définissant un système de
rotation à l’aide du positionnement des images des demi-arêtes dans un voisinage de l’image du sommet.
1.1.2
Les différents types de cycles
Courbes On considère les courbes C sur une surface S définies par une application continue fC de
[0; 1] dans S. Une courbe est un lacet si, et seulement si, fC (0) = fC (1). Cette courbe est simple si, et
seulement si, fC est injective sur [0; 1[. On dit que deux courbes C1 et C2 sont librement homotopes s’il
existe une application continue H de [0; 1] × [0; 1] dans S telle que H(0, .) = fC1 et H(1, .) = fC2 .
Cas des graphes plongés Dans le cadre des graphes plongés, on va considérer des cycles correspondant
à des chemins d’arêtes. Un tel cycle est simple si elle n’a pas de croisement. Un croisement est une notion
délicate à définir. On va choisir une approche géométrique pour comprendre le phénomène. Ainsi, étant
donné un voisinage tubulaire quelconque de l’intersection de 2 cycles, on va considérer que 2 cycles ne se
croisent pas si on peut les transformer en courbes disjointes grâce à une homotopie. Sur l’exemple suivant,
on voit le cas de 2 courbes C1 et C2 qui ont une intersection non-vide :
C1
C2
C1
C2
C1
C2
C2
C1
Figure 1 – 2 orientations différentes pour les cycles C1 et C2.
Sur l’exemple de gauche on va pouvoir trouver une perturbation qui sépare les courbes alors que ce ne
sera pas le cas pour la seconde configuration (figure 2). D’une façon générale, on va plus s’intéresser au
nombre de croisements entre deux courbes qu’au nombre d’intersections entre celles-ci.
3
C1
C2
C1
C1
C2
C2
C2
C1
Figure 2 – Les courbes de gauche ne se croisent pas contrairement à celles de droite.
Types de cycles On distingue plusieurs natures différentes pour les cycles de la surface :
Définition 4 (Cycle contractile). On dit qu’un cycle est contractile si, et seulement si, il est homotope à
un point. De manière équivalente,on peut considérer qu’il borne un disque topologique.
Sur la sphère, tous les cycles sont contractiles. On va souvent dire que ces cycles sont triviaux et on
va surtout s’intéresser aux cycles qui ne sont pas contractiles. On considère ensuite la propriété suivante :
Définition 5 (Cycle séparateur). Un cycle est dit séparateur si, et seulement si, la surface privée de ce
cycle a 2 composantes connexes.
Il est clair qu’un cycle contractile est séparateur, il est moins
naturel d’imaginer des cycles non-contractiles puisqu’ils n’en exisC1
tent pas sur la sphère. Sur un double-tore (surface de genre 2), on
peut voir toutes les configurations possibles comme le montre la
C3
figure ci-contre. Le cycle C1 est contractile et donc séparateur. C2
C2
est un cycle non-contractile et non-séparateur, on peut déjà trouver
ce type de cycle sur un tore simple. C3 est dans une configuration
particulière qui nécessite une surface de genre 2 car il est séparateur
Figure 3 – Les différents cycles.
mais non-contractile, il est nécessaire que le genre de chaque partie
résultant du découpage le long de C3 soit non-nul pour que ce cycle
ne soit pas contractile, le genre 2 est donc bien minimal. On a alors la définition suivante :
Définition 6 (Cycle de partage). On dit d’un cycle séparateur non-contractile qu’il est un cycle de
partage.
1.1.3
Décomposition arbre-coarbre
Dual d’un graphe Étant donné un graphe plan G, on note G∗ son dual. Les sommets de G∗ sont les
faces du graphe G et on crée une arête e∗ pour chaque arête e de G. e∗ relie alors les 2 faces adjacentes à
e dans G. Cette notion habituelle des graphes planaires peut s’étendre sans problème au graphes plongés
sur des surfaces de genre non-nul.
Arbre de recouvrement Un arbre de recouvrement de G est un sous-arbre qui contient tous les
sommets de G. On parle souvent d’arbre de recouvrement minimal quand on cherche à minimiser la
somme des poids des arêtes. On obtient un arbre de recouvrement quand on construit un arbre de plus
courts chemins indépendamment du choix de la base.
Structure du dual On le note (G − T )∗ , le graphe dual auquel on a retiré les arêtes d’un arbre de
recouvrement T . Dans le cas des graphes planaires, (G − T )∗ est un arbre, on parle donc de décomposition
arbre-coarbre. Dans le cas des graphes plongés sur une surface de genre g, on obtient un arbre et 2g arêtes
supplémentaires (le nombre d’arêtes supplémentaires est une conséquence directe de la caractéristique
d’Euler).
4
Application Cette structure va nous donner un moyen de construction de cycles non-contractiles. Pour
commencer, on choisit un sommet s qui va nous servir de base puis on se donne un arbre de recouvrement
T . Pour toute arête uv qui n’est pas dans T , on peut alors facilement savoir si le cycle C composé des
chemins dans T de s à u et de s à v et de l’arête uv est contractile ou non avec le résultat suivant [16] :
Théorème 1. Pour un graphe G et avec les définitions données ci-dessus, on a :
C est contractile si, et seulement si, (G − T )∗ − {uv}∗ a une composante connexe qui est un arbre.
1.2
1.2.1
Les algorithmes statiques
Applications directes de la décomposition arbre-coarbre
Plus courte boucle non-contractile de base donnée On peut l’obtenir en temps O(n · log(n))
[10, 16]. Étant donné un sommet s du graphe, on va construire l’arbre de plus court chemin issu de
s. On va alors utiliser le théorème précédent pour savoir quand on a atteint un cycle non-contractile.
Effectivement, on imagine qu’on fait grossir un disque autour de s et dès que le disque nous donne un
cycle (quand deux partie se rejoignent), on teste la contractibilité de ce cycle. L’algorithme se termine
quand le cycle testé n’est pas homotope à un point et renvoie ce cycle. On peut alors démontrer que ce
cycle est bien le plus petit cycle non-contractile de base s. D’une façon générale, les plus courts cycles
non-contractiles auront toujours cette forme : un sommet s et deux plus courts chemins qui relie s aux
deux extrémités d’une arête.
Base optimale d’homotopie Erickson et Whittlesey ont présenté un algorithme de calcul d’une base
optimale d’homotopie en O(n · log(n)) [11]. L’algorithme fonctionne d’une façon similaire à l’algorithme
précédent mais il continue jusqu’à obtenir une base du groupe fondamental.
Plus court non-contractile en O(gnk) Cabello, de Verdière et Lazarus [3] nous donnent un algorithme pour calculer un tel cycle dont la complexité dépend de la longueur k du cycle recherché (en
nombre d’arêtes, ici le graphe n’est pas pondéré pour simplifier la compréhension de la complexité). Pour
chaque nombre entier k0 , cet algorithme recherche un ensemble de sommets de taille O(gk0 ) dont l’étude
en O(n) permet de conclure de façon certaine sur la présence d’un cycle non-contractile de longueur k0 .
Ensuite, en choisissant des valeurs de k en progression géométriques, on obtient la complexité annoncée.
Cet algorithme permet d’obtenir un plus court cycle non-séparateur d’une manière analogue. La plupart
des algorithmes permettent ainsi d’obtenir plusieurs types de cycles de la même façon et peuvent s’adapter
à plusieurs cadres différents sans difficulté. Cet algorithme, par exemple, fonctionne parfaitement pour
un graphe pondéré. Cependant, chaque changement nécessite une attention particulière. Ainsi, si on s’autorise à travailler avec des surfaces à bord cet algorithme fonctionne parfaitement mais voit sa complexité
légèrement transformée (g devient g +b avec b le nombre de bords). Par contre, il ne permet pas de trouver
le plus court cycle essentiel (non-contractile et non-homotope à un bord). Le problème devient alors plus
compliqué et on utilise le résultat suivant :
Plus court cycle essentiel en O(n2 log(n)) Erickson et Worah [12] décrivent la situation en détail
et donne un algorithme avec un pré-calcul en O(n2 log(n)) puis une requête effectuée en O(n2 ). En fait,
la difficulté vient du fait qu’étudier les cycles définis à partir d’un sommet, d’une arête et de 2 plus
courts chemins n’est pas suffisant. Il est nécessaire de considérer les cycles composés de deux arêtes et
2 plus courts chemins. Le pré-calcul réalise Dijkstra sur tous les sommets, ce qui donne tout de suite la
complexité finale. Ensuite, chaque paire d’arête est testée en O(1) ce qui donne la complexité de la requête.
Cet algorithme a une complexité bien moins bonne par rapport à n que les algorithmes précédents, ce qui
confirme que le problème du plus court essentiel est significativement différent du problème du plus court
non-contractile. Cependant, il a l’intérêt de ne pas faire intervenir le genre de la surface.
5
1.2.2
Condition des 3 chemins (3-path condition) et découpages
Définition 7 (Condition des 3 chemins). Soit L un ensemble de lacets, alors on dit que L vérifie la
condition des 3 chemins si, et seulement si, elle vérifie les 2 conditions suivantes :
1. Si α ∈ L alors α−1 ∈ L
2. Si α, β et γ sont 3 chemins de mêmes extrémités tels que : α · β −1 et β · γ −1 sont dans L
alors α · γ −1 est dans L.
L’ensemble des cycles contractiles respecte la condition des 3 chemins. L’intérêt de remarquer ce
phénomène est d’obtenir le résultat suivant :
Théorème 2. Un plus court cycle non-contractile du graphe (de base non-fixée) ne croise pas plus d’une
fois un plus court chemin.
Avec ce point de vue, on va trouver d’autres algorithmes intéressants :
Plus court non-contractile en O(2O(g) n · log(log(n))) Fox [14] utilise la remarque précédente pour
réduire le nombre de classes d’homotopie susceptibles de contenir un plus petit cycle non-contractile. Cet
algorithme nécessite d’obtenir une base d’homotopie optimale pour pouvoir utiliser le résultat ci-dessus
et utilise donc l’algorithme correspondant décrit dans la section précédente. Enfin, le facteur log(log(n))
est obtenue à la place de log(n) grâce à un algorithme décrit par Italiano [15]. Cet algorithme obtient la
meilleur dépendance en n au prix d’une dépendance exponentielle en g.
Plus court non-contractile en O(g2 n · log(n)) Cabello, Chambers et Erickson [2] nous fournissent
un algorithme équilibré en terme de complexité (quasi-linéaire en n et quadratique en g) qui sera un
bon candidat si on n’a pas d’information sur le genre de la surface et la structure du graphe. A genre
fixé, il n’est que légèrement moins bon que le précédent (asymptotiquement mais ce n’est pas certain en
pratique) et est meilleur que l’algorithme basique qui consisterait à réaliser l’algorithme qui trouve le plus
√
court non-contractile basé en un sommet quelconque pour chaque sommet du graphe dès que g = o( n).
L’algorithme nécessite de faire des requêtes de la forme : Quel est le plus court cycle qui coupe un chemin
simple donné α exactement une fois ? Cette partie se fait en O(gn · log(n)) (cf. section 1.3.1). L’algorithme
réalise une série de découpage de la façon suivante : on choisit un sommet quelconque s et on demande
le plus court non-contractile basé en s. Ensuite, pour découper le long de ce cycle, on en duplique les
sommets et on affecte les arêtes à l’une des deux copie du sommet en respectant l’orientation. Si le cycle
était séparateur, on obtient 2 surfaces disjointes avec chacune 1 bord (cf. figure 3, cycle C3) et si le cycle
n’était pas séparateur on obtient 1 surface avec 2 bords (cf. figure 3 cycle C2). Dans ce dernier cas, on
demandera les plus court cycles homotopes aux bords puis on va chercher le plus court chemin qui relie
les 2 bords et, en découpant le long de ce chemin, on se ramera à une surface avec 1 unique bord. Pour les
surfaces avec 1 unique bord, on va chercher un plus court homotope à ce bord puis on va ”remplir” le bord
grâce à un disque et on se retrouve dans la situation initiale. à chaque étape, le genre global diminue et
on obtient un nombre fini de candidat potentiels pour le plus court non-homotope. Ainsi, en O(g) étapes
chacune de complexité O(g · log(n)) on obtient le résultat.
1.3
1.3.1
Algorithmes dynamiques ou utilisant des méthodes dynamiques
Plus courts chemins à sources multiples
On s’intéresse ici au problème de la construction des arbres de plus courts chemins de tous les sommets
adjacents à une face donnée. On doit commencer par construire un arbre de plus courts chemins pour un
sommet fixé. Pour faire cela dans le cadre des graphes plongés en genre quelconque, on utilise l’algorithme
de Dijkstra. L’idée est de construire les autres arbres à partir de ce premier calcul.
6
Méthode Supposons qu’on connaisse l’arbre de plus courts chemins pour un sommet u incident à la
face considérée f . Alors on souhaite en déduire l’arbre de plus court chemin issu de v, un voisin de u
incident à f . On va alors rajouter un sommet fictif x et remplacer l’arête uv par 2 arêtes ux et xv.
Initialement, on affecte à ces arêtes les poids suivants : w(ux) = λ · w(uv) et w(xv) = (1 − λ) · w(uv).
x joue le rôle de u quand λ = 0 et le rôle de v quand λ = 1. On va alors faire varier λ continûment de
0 à 1 pour obtenir l’arbre de plus courts chemins issu de v. Quand λ varie, pour certaines valeurs, une
arête peut basculer dans l’arbre alors qu’elle n’en faisait pas partie jusqu’à présent. On dit alors que cette
arête est un pivot (cf. section 4.2 pour plus de détails). Chaque opération de pivot va être effectuée en
temps O(g · log(n)) grâce à la structure de donnée des arbres dynamiques (cf. section 2). Pour construire
l’ensemble des arbres correspondant aux sommets de f , on va avoir au maximum O(gn) phases de pivots.
On obtient une complexité en O(g 2 n · log(n)). Une étude fine permet de s’apercevoir qu’on peut améliorer
cette complexité en la divisant par g.
Lien avec l’algorithme de Cabello, Chambers et Erickson On dispose d’un graphe G plongé
dans une surface de genre g et d’un cycle simple non-séparateur α (premier dessin). On va dupliquer les
Figure 4 – Exemple de découpage sur un tore.
sommets de α et on affecte les arêtes en respectant l’orientation (second dessin). On a alors une surface
avec 2 bords qu’on ”bouche” en recollant des disques (troisième dessin). Les 2 copies de α bordent alors
des faces, l’une d’elle servira de face de base pour l’algorithme précédent, on la note f . On cherche alors
le plus court chemin reliant un point de f à son double. Ainsi, on testera bien tous les cycles qui croisent
α exactement 1 fois (quatrième dessin). Cette méthode permet d’obtenir le résultat utilisé dans la section
1.2.2.
1.3.2
Base d’homotopie dynamique
Eppstein nous livre un algorithme dynamique pour mettre à jour une base du groupe fondamental [8].
Il travail dans la cadre des cartes combinatoires orientables ou non. On va se restreindre au cas orienté
pour plus de clarté. La complexité de l’algorithme est O(g · log(n)) et peut, grâce un raffinement de la
structure de données utilisée, être améliorée en O(log(n) + log(g)log(log(g))3 ).
Principe On va utiliser une décomposition arbre-coarbre. Pour l’arbre de recouvrement, on utilise un
arbre de recouvrement minimal T . Ensuite on considère C l’arbre de recouvrement maximal du graphe
dual, et il nous reste 2g arêtes qu’on place dans un ensemble X. Alors, en choisissant un sommet s comme
base, et en associant un lacet à chaque arête de X (cf. section 1.2.1), on construit une base du groupe
fondamental. Ces données vont être stockées sous la forme d’arbres dynamiques (cf. section 2). C’est
cette structure de données qu’on va mettre à jour à chaque changement du graphe. Étant donnée une
modification d’une arête du graphe, on va se demander quel nombre d’opérations il faut exécuter pour
mettre à jour notre structure de données. Chacune de ces opérations sera réalisée en O(log(n)) grâce aux
arbres dynamiques.
Cas de l’ajout d’une arête Regardons plus en détail le cas particulier de l’ajout d’une arête. Deux
situations se présentent. Soit (a) les 2 demi-arêtes de l’arête ajoutée sont dans la même face soit (b) elles
ne le sont pas :
7
f
f
(a) Les demi-arêtes sont
dans la même face.
g
(b) Les demi-arêtes ne sont pas dans la même face.
Figure 5 – Impact de l’ajout d’une arête.
Dans le cas (a), la face f est simplement découpée en 2 faces plus petites. Ainsi, le nombre de face
et le nombre d’arêtes augmentent de 1, la caractéristique d’Euler est inchangée et le genre de la surface
est donc conservé. Dans le cas (b), on voit qu’on a dû rajouter une ”poignée” pour pouvoir dessiner le
nouveau graphe. En fait, les faces f et g sont réunies en 1 seule face. La caractéristique d’Euler est alors
diminuée de 2, ce qui correspond à une augmentation du genre de 1 (cf. section 1.1.1). Dans chaque cas,
on modifie T , C et X pour obtenir la nouvelle base.
2
Étude des arbres dynamiques
2.1
Cadre
On considère des forêts d’arbres enracinés. On s’autorise les 2 opérations suivantes sur les forêts :
1. link (v,w) : cette opération ajoute une arête entre v et w. Cette opération nécessite que v et w soient
dans le même arbre (on considère v comme un nouveau fils de w).
2. cut(v,w) ou cut(v) : cette opération élimine l’arête entre v et w et transforme donc l’arbre qui
contenait v et w en 2 arbres disjoints. Si w n’est pas précisé, c’est qu’il est le parent de v.
Dans tous les cas, ces opérations vont être exécutées en O(log(n)).
2.2
Splay-Trees
Tarjan donne la description détaillée de cette structure de donnée [18].
2.2.1
Idée
On suppose qu’on a un ensemble ordonné stocké dans un arbre de recherche binaire. La recherche d’un
élément dans l’arbre est alors proportionnel à la profondeur de l’élément recherché. Une idée classique est
de considéré qu’on va souvent accéder aux mêmes éléments et donc qu’il est intéressant, quand on accède
à une donnée, de transformer l’arbre de recherche pour que la donnée en question en devienne la racine.
On peut réaliser facilement cette opération en effectuant des rotations dans l’arbre. Cependant, pour des
raisons pratiques, on va quasiment toujours utiliser le système de splaying pour effectuer un accès dans
l’arbre. Cette méthode est très intéressante car elle permet non-seulement d’accéder à un sommet donné
mais aussi de rapprocher de la racine tous les sommets du chemin d’accès. Ces sommets sont effectivement
de bons candidats pour une prochaine demande.
8
z
x
y
y
x
C
A
B
x
y
x
D
B
C
A
(a) Zig : Dernière étape, quand
x est un descendant direct de la
racine de l’arbre.
y
x D
z
A
B
B
x
y
z
A
C
A
z
y
C
D
(b) Zig-Zig.
B
A
C
B C
D
(c) Zig-Zag.
Figure 6 – Les opérations du ”Splaying”.
Splaying On va ramener notre élément x vers la racine en utilisant les 3 opérations suivantes :
Ces opérations sont donc les opérations de base qui vont être pratiquées dans les structures de données
d’arbres dynamiques.
2.2.2
Opérations
1. access(i,t) : Renvoie un pointeur sur i si cet objet est présent dans l’arbre t (NULL sinon).
2. insert(i,t) : Ajoute i dans t.
3. delete(i,t) : Supprime l’élément i dans t.
4. join(t1 ,t2 ) : Transforme les 2 arbres en 1 seul (on suppose que tous les éléments de t1 sont plus
petits que tous ceux de t2 .
5. split(i,t) : supprime l’élément i dans t et renvoie 2 arbres, t1 avec tous les éléments plus petits que
i et t2 avec tous les éléments plus grands que i.
2.2.3
Application aux link-cut trees
Les link-cut trees représente la première structure de données performante pour gérer des arbres
dynamiques [20]. La version actuelle de cette structure de donnée utilise des splay trees. Dans tous les
cas, cette structure de donnée est centrée sur les chemins. On peut, dans ce cadre, réaliser toutes les
opérations suivantes en temps O(log(n)) :
1. find-cost(v) : renvoie la valeur associée au sommet v.
2. find-root(v) : renvoie la racine r de l’arbre qui contient v.
3. find-min(v) : renvoie le sommet avec la valeur minimum sur le chemin de v à r.
4. add-cost(v,x) : ajoute la valeur x à tous les sommets sur le chemin de v à r.
On ne va pas décrire cette structure en détails mais plutôt se concentrer sur les versions plus complètes
dans les sections suivantes. On aura effectivement besoin d’opérations sur les sous-arbres qui ne sont pas
gérées par les link-cut trees.
2.3
Euler-Tour Trees
On trouve la description détaillée de cette structure de donnée dans la référence [21].
2.3.1
Opérations
L’intérêt principal de cette structure de donnée est l’utilisation de sous-arbres plutôt que de chemins.
On obtient les opérations suivantes en temps O(log(n)) :
1. find-val (v) : renvoie la valeur associée à v.
2. find-min(v) : renvoie le sommet associé à la plus petite valeur dans l’arbre contenant v.
9
3. change-val (v,x) : affecte la valeur x au sommet v.
4. add-val (v,x) : ajoute une valeur x à la valeur de chaque sommet dans l’arbre contenant v.
En composant les opérations suivantes avec quelques link et cut, on peut obtenir les opérations suivantes
en O(log(n)) :
1. sub-find-min(v) : renvoie le sommet avec le poids minimum dans le sous − arbre de racine v.
2. sub-add-val (v,x) : ajoute une valeur x à la valeur de chaque sommet dans le sous − arbre de racine
v.
2.3.2
Fonctionnement
Idée On modifie chaque arbre en transformant chaque arête en une paire d’arêtes d’orientations opposées
et on ajoute une boucle sur chaque sommet. On remarque alors que notre nouveau graphe dispose d’un
cycle eulérien, qu’on utilise pour représenter le graphe.
Résultat On peut alors considérer notre forêt comme une liste. On a immédiatement link et cut en
O(1). Cependant les autres opérations sont a priori en O(n). On va améliorer ces résultats en voyant les
listes comme des splay-trees et on obtient alors les résultats en O(log(n)).
2.4
Top-Trees
On trouve la description détaillée de cette structure de donnée dans [22]. Cette version est la plus
aboutie des structures d’arbres dynamiques. Cependant, cette structure est largement plus difficile à
appréhender que les Euler-Tour trees. De plus, on verra que la variété des opérations rendues possibles
a un coût pour les applications pratiques. D’un point de vue théorique il est néanmoins très favorable
d’utiliser cette structure de données.
2.4.1
Fonctionnement
Idée On va retenir une façon de contracter l’arbre jusqu’à le réduire à 1 sommet. Pour effectuer cette
réduction, on ne s’autorise que les 2 opérations suivantes, qu’on réalise en série :
v
v
u
w
w
u
w
w
(a) compress(v).
(b) rake(v).
Figure 7 – Transformations des top-trees.
compress nécessite que v soit de degré 2 et rrake que v soit de degré 1. A une certaine étape de contraction,
on dit qu’on a des ”clusters” plutôt que des sommets. Chaque ”clusters” contient une certaine partie de
l’arbre initial. Les informations ainsi obtenues seront conservées sous la forme d’un arbre de petit degré.
Restriction Conceptuellement assez simple, cette structure de données semble bien adaptée aux problèmes
d’arbres dynamiques. Cependant, les opérations classiques ne vont être effectuées en O(log(n)) qu’à condition que les arbres considérés aient un degré borné. Si ce n’est pas le cas, il faut passer par une ternairisation des arbres, ce qui complique largement la structure de données et peut largement alourdir le
graphe. Le problème peut être réglé au prix d’une importante sophistication dont on retiendra qu’elle
n’est pas nécessaire dans tous les cas.
10
2.4.2
Opérations
En plus des opérations link, cut et expose, on a naturellement les fonctions suivantes en O(log(n)) :
1. find-cost(v) : renvoie la valeur associée au sommet v.
2. find-root(v) : renvoie la racine r de l’arbre qui contient v.
3. find-min(v) : renvoie le sommet avec la valeur minimum sur le chemin de v à r.
4. add-cost(v,x) : ajoute la valeur x à tous les sommets sur le chemin de v à r.
On retrouve aussi les opérations des Euler-Tour trees mais l’implémentation est moins naturelle :
1. sub-find-min(v) : renvoie le sommet avec le poids minimum dans le sous − arbre de racine v.
2. sub-add-val (v,x) : ajoute une valeur x à la valeur de chaque sommet dans le sous − arbre de racine
v.
On voit ici l’intérêt théorique de cette structure qui permet de gérer l’ensemble des opérations des arbres
dynamiques. Vient alors la question : ”Pourquoi ne pas considérer uniquement cette structure dans tous les
cas qui demandent de travailler avec des arbres dynamiques ?”. La section suivante traite cette question.
2.4.3
Défauts
Une étude précise des avantages et inconvénients de chaque structure est réalisée par Tarjan [23].
L’implémentation des top-trees est lourde et moins efficace en temps ainsi qu’en espace utilisé que les
autres structures. Si on ne veut que des opérations sur les chemins, les link-cut trees (ou ST-trees) sont
bien plus efficaces et si on ne veut que des opérations sur des sous-arbres, les Euler-Tour trees sont plus
efficaces. Les top-trees ont donc un intérêt théorique et ne sont utiles en pratique que dans des cas qui
demandent une grande liberté d’action sur les arbres dynamiques.
3
Du statique vers le dynamique
3.1
3.1.1
Cadre de l’étude, premières remarques
Problème étudié
Cadre On va utiliser les notations décrites dans la section 1. De plus, le graphe G = (V ; E) considéré
sera pondéré, non-orienté et donné avec un plongement explicite sur une surface de genre g. Il sera
intéressant de considérer que le graphe est orienté mais que toutes les pondérations sont symétriques
(∀(u, v) ∈ V 2 , w(uv) = w(vu)). Ce point de vue est utile dès qu’on parle d’arbre de plus courts chemins
dans lesquels les arêtes sont naturellement orientées depuis la racine. De plus, ce point de vue est cohérent
avec les demi-arêtes qui définissent le système de rotations qui donne le plongement du graphe. On
choisit un cadre dynamique simple. On considère que le poids d’une unique arête est modifié. Les cas
d’augmentation du poids ou de diminution du poids devront être décrit séparément dans la plupart des
cas. Notons que la suppression d’une arête e peut-être simulée par l’affection w(e) = +∞.
Algorithme On étudie en particulier le cas de la recherche du plus court cycle non-contractile du
graphe (cf. section 1). La longueur d’un cycle est la somme des poids arêtes qui le composent (comptées
avec leur multiplicité). Par la suite, la notation ”plus court cycle” devra être comprise comme ”plus cycle
non-contractile” si rien n’est précisé.
Théorème 3. Le plus court cycle non-contractile d’un graphe plongé sur une surface de genre g ≥ 1 est
toujours simple.
11
On notera cependant que cette propriété n’est pas vraie si on considère le plus courte lacet noncontractile de base donnée. On utilisera aussi le théorème de la section 1.2.2 qui nous dit que notre plus
court cycle non-contractile ne peut être croisé deux fois par un même plus court chemin. On notera
que cette propriété n’est vraie que si le graphe est non-orienté [9]. Ce résultat permet aussi d’étudier
immédiatement certains cas :
Diminution du poids de l’arête e Si e fait partie de l’ancien plus court cycle, alors, le nouveau
plus court cycle est le même et sa longueur est diminuée de la même valeur que le poids de e. C’est une
conséquence de la simplicité du plus court cycle non-contractile.
Augmentation du poids de l’arête e Si e n’appartient pas à l’ancien plus court cycle alors celui-ci
est toujours le plus court cycle et sa longueur n’est pas modifiée.
3.1.2
Remarques préalables
Diminution du poids de l’arête e
Situation Compte-tenu des remarques précédentes, on peut se demander ce qu’il peut se passer
quand e n’appartient pas à l’ancien plus court cycle. Les seuls cycles dont le poids est modifié sont ceux
qui contiennent e. Ainsi, le nouveau plus court cycle ne peut être que l’ancien plus cycle ou le plus court
cycle contenant e. Il suit que la diminution du poids du plus court cycle est majoré par la diminution du
poids de e (comme le cycle recherché est simple).
Résolution directe Si on imagine que le poids de e diminue continûment, on peut se demander
pour quelle valeur (si elle existe) le plus court cycle devient celui qui passe par e. Avec les algorithmes
statiques qu’on connaı̂t, on peut considérer le graphe où on a contracté l’arête e et on cherche le plus
petit cycle de base ”e”. On obtient un résultat en O(n · log(n)) de longueur l. Le plus court cycle passant
par e dans le graphe initial a alors un poids de l + w(e) ce qui nous donne immédiatement toutes les
informations dont on a besoin.
Augmentation du poids d’une arête e Ici, on suppose que e appartient à l’ancien plus court cycle.
Ce cycle restera le plus court cycle simple non-contractile qui contient e. L’autre cycle à considérer serait
le plus court cycle ne contenant pas e. La difficulté de cette configuration est que le nouveau plus court
cycle peut être n’importe où et il ne semble pas possible de trouver ce candidat sans refaire une recherche
complète.
3.2
3.2.1
Première approche
Idée
La structure d’arbres dynamiques nous amène à envisager d’utiliser au maximum les arbres de plus
court chemins. Ainsi, pour résoudre le problème du plus court cycle non-contractile, on peut initialiser
notre algorithme en calculant l’ensemble des arbres de plus courts chemins basés en chacun des sommets du
graphe. Ensuite, la mise à jour de chacun de ses arbres permettra à la fois d’obtenir le nouveau plus court
cycle et de mettre à jour notre structure de données à condition de pouvoir maintenir non-seulement les
arbres de plus courts chemins mais aussi les décompositions arbre-coarbre avec les informations nécessaires.
On suppose qu’on est toujours dans le cas d’un graphe G de genre g ≥ 1. Dans ce cadre, la construction
de chacun des n arbres de plus courts chemins est effectué en O(n · log(n)) en utilisant l’algorithme de
Dijkstra. Avant de regarder plus en détail cette approche, il est nécessaire de vérifier que le problème des
plus courts chemins pour toutes les paires ne fournit pas une meilleure approche.
12
3.2.2
Plus courts chemins pour toutes les paires
Algorithmes de base L’algorithme le plus classique pour résoudre le problème des plus courts chemins
pour toutes les paires est un algorithme en O(n3 log(n)) [5] basé sur la multiplication de matrices faisant
intervenir la matrice d’adjacence et une matrice particulière qu’on appelle matrice de liaison. De nombreux
algorithmes [4, 7, 13] donnent des améliorations de ce résultats (parfois dans des cas particuliers). les
résultats se rapproche dans le cas général d’une complexité en O(n3 /log 2 (n)). Un autre algorithme consiste
à simplement appliquer le problème des plus court chemins de base fixée à tous les sommets, ce qui donne
une complexité en O(mn + n2 log(n)) en appliquant Dijkstra avec des tas de Fibonacci. Cette approche
n’est valable que si le graphe n’a que des arêtes de poids positifs. Dans le cas contraire, l’utilisation de
l’algorithme de Bellman-Ford est requise, ce qui rend la méthode peu viable.
Cas dynamique Ce problème a été étudié dans de nombreux articles [6, 1, 24]. La plupart des méthodes
utilisées font intervenir la multiplication de matrices et les résultats sont en O(na ) où 2 < a < 3. Ces
résultats ne sont pas utiles quand on a m=O(n) car il est alors plus simple d’actualiser des arbres de plus
court chemin sur chaque sommet.
Conclusion Ces remarques confirment bien que l’approche envisagée peut être intéressante. Effectivement, dans le cas des graphes plongés en genre g, on a m =O(n). Ainsi, la prochaine étape est de regarder
ce qui peut être fait pour maintenir les arbres de plus courts chemins tout en rajoutant les informations
dont on a besoin pour trouver les cycles non-contractiles.
3.2.3
Plus courts chemins dynamiques de base fixée
Contexte Pour utiliser des arbres dynamiques, on commence toujours par se poser la question de la
structure la plus adaptée. Il est clair qu’on aura besoin de faire des modifications plutôt sur des sous-arbres
que sur des chemins, les ET-trees sont alors les plus appropriés. Les algorithmes dans le cas général ne
sont pas forcément les plus performants comme on peut le voir dans les applications de l’article [23] qui
compare l’efficacité relative des structures définies à la section 2. On verra plus tard que le cas des graphes
plongés en genre g ≥ 1 nécessite aussi de réaliser des opérations sur les chemins et on sera donc amené à
utiliser les Top-trees [2]. On va utiliser la décomposition arbre-coarbre décrite dans la section 1.1.3. On a
alors quelques définitions :
Définition 8 (Tension). La tension t(u → v) d’une arête u → v pour un arbre de plus courts chemins
Ts de base s (on note d(x) la distance de s à x) est donnée par :
t(u → v) = d(u) + w(u → v) − d(v)
Toutes les arêtes présentes dans Ts ont une tension nulle. Une arête qui n’est pas présente dans l’arbre
est dite active si sa tension décroit.
Définition 9 (Pivot). La première arête dont la tension atteint 0 est le prochain pivot.
Phases de pivot Chaque phase débute par la recherche du prochain pivot. Dans le cas d’un graphe
planaire, on réalise simplement une opération find-min dans le coarbre (on recherche le minimum de
tension). Ensuite, on doit réaliser l’opération correspondant au pivot sur l’arbre, c’est-à-dire l’intégration
du pivot dans Ts . Si link et cut ne posent pas de problème, on doit nécessairement avoir recours aux
arbres dynamiques pour actualiser les valeurs de la fonction d(·). Cela ne nécessite que des opérations sur
des sous-arbres.
13
Utilisation du dual pour trouver le prochain pivot Le but de l’exercice est de trouver l’arête avec
la plus petite tension parmi les arêtes qui ne sont pas encore présentes dans l’arbre. Ainsi, on va s’intéresser
au graphe (G − T )∗ . Dans le cas des graphes de genre g ≥ 1, on a un arbre avec 2g arêtes supplémentaires.
On va alors devoir utiliser la structure de ”grove” décrite par Cabello [2]. En fait, on va découper notre
graphe (G − T )∗ en O(g) arbres, chacun pouvant donner un candidat pour le prochain pivot en O(log(n)).
Cela nous donne une complexité en O(k · g · log(n)) pour k phases de pivots. Cependant, grâce à une
structure de file de priorité, on peut améliorer ce résultat d’un facteur g si on fait plusieurs mises à jour
successives du même arbre [2]. À cette étape, il est nécessaire de réaliser des opérations sur les chemins. Ce
point est très technique et bien abouti, une attention toute particulière pourra, cependant, être apportée
au nombre de pivots qu’il faudra utiliser dans notre recherche du plus court cycle non-contractile. Ce
point est développé dans la section suivante.
3.3
3.3.1
Nombre de pivots
Pour un arbre de plus courts chemins donné
On fixe un sommet s et son arbre de plus courts chemins Ts . Il s’agit tout d’abord de comprendre
ce qu’il peut se produire lorsqu’on modifie le poids d’une arête uv. Prenons l’exemple d’une diminution
de w(uv) vers w0 (uv). Si uv n’apparaissait pas dans Ts alors elle sera présente dans l’arbre Ts0 (arbre
de plus courts chemins après la modification de poids de uv) si, et seulement si, d(u) + w0 (uv) < d(v)
ou d(v) + w0 (uv) < d(u) (c’est à dire si uv permet de rapprocher u ou v du sommet s). Si ce n’est
pas le cas, il ne se passe rien car aucune distance n’est modifiée. Si uv est dans Ts0 alors d’autres arêtes
peuvent pivoter. Supposons qu’une arête a ← b pivote avec cette orientation. Le chemin de s à b est alors
diminué, il contient alors l’arête uv qui est la seule à être modifiée tandis que le chemin de s à b dans
Ts ne contenait pas uv. Les pivots font alors tous passer un sommet supplémentaire dans les descendants
de u (ou v suivant l’orientation de uv dans Ts0 ). Une arête donnée ne peut donc pivoter qu’une fois au
maximum. Un raisonnement similaire dans le cas d’une augmentation de poids nous donne le résultat
suivant :
Théorème 4 (Borne supérieure). Si on modifie le poids d’une unique arête du graphe alors le nombre de
pivots dans un arbre de plus courts chemins donné est majoré par n.
Cette borne est bonne car on obtient un exemple qui atteint cette borne :
Figure 8 – Exemple planaire pour une source unique s.
Si le poids de l’arête sb passe continûment de 3 à 1, on aura n − 3 phases de pivots pour chaque valeur
de sb de la forme 1 + k/n pour n ∈ [[1; n − 3]] :
3.3.2
Sur l’ensemble des arbres de plus courts chemins
Certaines approches globales permettent parfois d’obtenir une borne sur le nombre de pivots. Par
exemple, si toutes les sources sont autour d’une même face, on peut exploiter cette caractéristique de
14
1
a
1
1+1/n
s
3
1+(n-3)/n
a
s
1
b
1
b
1
Figure 9 – Les arbres de plus courts chemins avant et après le changement de poids.
façon intéressante [2], on va voir si on peut obtenir un résultat en considérant le graphe dans sa globalité.
Compte-tenu des résultats précédents, il apparaı̂t qu’il est possible de borner le nombre total de pivots
pour actualiser l’ensemble par n2 . Encore une fois un exemple va atteindre cette borne asymptotiquement :
Figure 10 – Exemple planaire sur l’ensemble du graphe.
L’arête modifiée est l’arête de poids 2 au centre de la représentation du graphe. Les poids distincts des
arêtes supérieures permettent d’obtenir des valeurs distinctes pour les différents pivots, et ainsi d’avoir
n/2 − 2 pivots pour n − 4 sommets. Ce qui nous donne la transformation suivante pour un sommet
quelconque s :
Figure 11 – Les arbres de plus courts chemins avant et après le changement de poids.
On a alors O(n2 ) pivots pour actualiser l’ensemble des arbres de plus courts chemins du graphe.
15
3.3.3
Résultat
Grâce aux algorithmes cités précédemment, on voit qu’on peut actualiser tout nos arbres de plus court
chemins en O(kg · log(n)) où k est le nombre de pivots nécessaires. Un algorithme permettant de trouver
le plus court cycle non-contractile devra de plus mettre à jour les longueurs de cycles correspondant à
chaque arête de (G − T )∗ . Cependant, les bornes trop élevées pour k ne donne pas d’intérêt réel à cette
approche.
3.3.4
Arbres couvrants
Eppstein nous livre un algorithme [8] qui permet d’actualiser une famille de générateurs du groupe
fondamental et un algorithme pour actualiser un arbre de recouvrement minimal. Pour le second point,
on peut se demander pourquoi le problème des pivots trop nombreux n’est pas un obstacle pour les arbres
de recouvrement minimaux. On peut déjà regarder comment se comporte cette structure sur le contreexemple précédent :
Figure 12 – Comportement d’un arbre de recouvrement minimal pour un changement de poids donné.
On voit que beaucoup plus d’arêtes sont conservées, en fait, on a fait qu’introduire de la façon la plus
efficace possible l’arête qui a changé de poids, le reste du graphe n’a pas été modifié. L’ancien arbre de plus
court chemin à qui on ajoute l’arête dont le poids est modifié contient un cycle, il suffit d’enlever l’arête de
poids le plus élevé qui ouvre ce cycle. Si l’arête est dans l’arbre et augmente de poids, on considère l’arbre
privé de cette arête et on cherche l’arête de poids le plus faible qui réuni les 2 composantes connexes pour
reformer un arbre. Cependant, avec un arbre de recouvrement minimal, la base du groupe fondamental
qu’on obtient en fixant un point base quelconque, n’est pas une base minimale. Il est néanmoins intéressant
de remarquer qu’un problème qui utilise des arbres de recouvrement sera bien plus facile à actualiser qu’un
algorithme qui nécessite l’utilisation d’arbres de plus courts chemins.
3.4
3.4.1
Autres approches
Autres algorithmes envisagés
La section précédente démontre qu’essayer d’adapter les algorithmes issus directement de la construction d’arbres de plus courts chemins n’est pas une bonne voie pour une approche dynamique. On va alors
essayer de se tourner vers les algorithmes de la section 1.2.2 qui utilisent plutôt des découpages successifs.
16
A première vue, le cadre ne semble pas favorable. Effectivement, prenons l’exemple de l’algorithme de Cabello qui débute par le calcul d’un plus court lacet non-contractile pour un sommet x fixé (sans condition
particulière sur x). Si ce lacet n’est plus le plus court non-contractile après modification du poids d’une
arête uv alors le découpage selon ce lacet n’est plus valide car on ne peut plus utiliser la condition des
3 chemins. Si on change de découpage alors les informations de l’algorithme initial n’ont plus d’intérêt
puisqu’elles ne portent pas sur les mêmes graphes que ceux qu’on obtient avec le nouveau découpage.
Pour palier à ce problème, on va envisager la question suivante :
Question 1. Un plus court chemin dans le graphe initial contient-il toujours des plus courts chemins de
taille significative dans le nouveau graphe où l’on a modifié le poids d’une unique arête ?
Si la réponse à cette question est positive, on pourra envisager de conserver un ancien découpage et il
faudra alors vérifier plus de cas pour la condition des 3 chemins mais le nombre de cas restera fini. Pour
commencer, on va répondre à cette question puis on regardera plus en détail comment ce résultat peut
être utilisé pour créer des algorithmes dynamiques.
3.4.2
Division d’un plus court chemin
On rappel d’abord le cadre pour plus de clarté. Dans un graphe G non-orienté pondéré par des nombres
réels positifs, on cherche à savoir quel est l’impact d’une modification d’arête sur la structure de plus courts
chemins du graphe. Dans chaque cas, diminution du poids ou insertion d’une arête et augmentation du
poids ou suppression d’une arête, on va montrer qu’un plus court chemin ne peut pas être découpé en
plus de 2 parties (séparées par une unique arête). On suppose l’unicité des plus courts chemins. On note
G le graphe de base et G0 le graphe modifié. On considère un plus court chemin d’une source s à une
destination t. Le résultat cherché est d’obtenir deux plus courts chemins dans G0 , de s à un sommet t0
puis de s0 à t avec t0 et s0 deux sommets consécutifs du chemin initial :
(a) Chemin initial.
(b) Résultat.
Figure 13 – Le découpage recherché
D’un point de vue théorique, on peut repérer le sommet s0 en parcourant le chemin de s à t, s0 est alors
le premier sommet x tel que le chemin de s à x n’est pas un plus court chemin dans G0 . On va avoir une
approche différente suivante la nature de la modification du graphe. Tout d’abord, on remarquera que le
résultat est immédiat dans le cas d’une augmentation de distance. Ensuite, on considérera le cas d’une
diminution de distance. Dans tous les cas, l’arête modifiée sera notée uv et on considère que le chemin de
s à t est noté P et est vu comme orienté de s à t.
Augmentation du poids ou suppression d’une arête Dans cette section, les chemins de G0 sont
plus longs que ceux de G, ce qui permet d’obtenir tout de suite le résultat. On distingue 2 cas :
uv ∈
/ P Le chemin P n’est pas modifié et les autres chemins ne peuvent qu’être ralongés. Ainsi P
est toujours un plus court chemin dans G0 .
uv ∈ P Disons que uv apparaı̂t dans P orienté de u à v. Les chemins de s à u et de v à t sont toujours
des plus courts chemins dans G0 , on est alors exactement dans la configuration décrite dans l’introduction.
Diminution du poids ou insertion d’une arête
17
Pour commencer, on élimine un cas simple :
uv ∈ P
Dans ce cas, le chemin P est toujours un plus court chemin dans G0 .
uv ∈
/ P Dans ce cas, il va falloir regarder plus en détail. On va raisonner par l’absurde. On note a
le premier sommet de P tel que le chemin de s à a n’est plus un plus court chemin dans G0 . On continue
ensuite le parcours le long de P et on note b le premier sommet tel que le chemin de a à b n’est plus un
plus court chemin dans G0 . On a alors un chemin composé d’un plus court chemin s à u (on suppose que
la première apparition de uv est orientées de u vers v) suivi de l’arête uv puis d’un plus court chemin de
v à a qui constitue le nouveau plus court chemin de s à a. Le même phénomène se produit de a à b mais
on ne peut plus choisir l’orientation de uv qui est déjà fixée. On a alors 2 cas, on fonction de l’orientation
de uv :
uv apparaı̂t avec 2 orientations opposées La situation est
alors représentée par la figure suivante : On a remplacé les chemins
par des arêtes dont le poids est égal à la somme des poids des arêtes
qui le composent (ou à 0 si on a ”éclaté” un sommet). On a alors
(w donne le poids d’un plus court chemin dans G et w0 dans G0 ) :
w0 (su) + w0 (uv) + w0 (va) < w(sa)
et donc
w0 (su)
Figure 14 – Schéma avec orientations opposées.
< w(sa).
De même, w0 (ub) < w(ab). Par définition, les 2 plus courts chemins
de s à u et de u à b ne contiennent pas l’arête uv. Leurs poids sont donc les mêmes dans G et dans G0 ,
on obtient la contradiction suivante :
w(su) + w(ub) < w(sa) + w(ab) = w(sb)
.
uv apparaı̂t avec la même orientation On reprend des notations similaires au cas précédent et on obtient la figure suivante :
Les hypothèses nous donne les inégalités suivantes :
w0 (su) + w0 (uv) + w0 (va) < w(sa)
et w0 (au) + w0 (uv) + w0 (vb) < w(ab)
Avec un raisonnement similaire au cas précédent, on obtient :
w0 (su) + w0 (ua) > w(sa) et w0 (av) + w0 (vb) > w(ab)
Figure 15 – Schéma avec les mêmes
orientations.
Par transitivité, on a alors :
w0 (su) + w0 (uv) + w0 (va) < w0 (su) + w0 (ua)
et w0 (au) + w0 (uv) + w0 (vb) < w0 (av) + w0 (vb)
En simplifiant, il vient :
w0 (uv) + w0 (va) < w0 (ua) et w0 (au) + w0 (uv) < w0 (av)
On omet w0 (uv) car il est strictement positif pour obtenir la contradiction (les plus court chemins étant
symétriques) :
w0 (va) < w0 (ua) et w0 (au) < w0 (av)
On a bien démontré dans tous les cas :
18
Théorème 5. Si T est un plus court chemin d’un sommet s à un sommet t dans un graphe G et si on
note G0 un graphe obtenu à partir de G en modifiant une unique arête alors :
∃t0 , s0 ∈ T tels que :
1. t0 s0 ∈ T .
2. T restreint au chemin de s à t0 est un plus court chemin dans G0 .
3. T restreint au chemin de s0 à t est un plus court chemin dans G0 .
3.4.3
Utilisation
On utilise souvent le corollaire de la condition des 3 chemins (théorème 2, section 1.2.2) dans les
algorithmes statiques. Grâce au théorème 5, on voit qu’en conservant l’ancien découpage on pourra affirmer
que le cycle recherché ne coupe notre ancien plus court cycle α qu’au plus 4 fois (α étant composé de 2 plus
courts chemins du graphe initial et donc de 4 plus court chemins du nouveau graphe). Cette approche peut
amener à une mise à jour efficace. Cependant, on se heurtera à un problème pour la partie qui nécessite
de trouver le plus court cycle homotope à α qui nécessite la mise à jour d’arbres de plus courts chemins.
4
Conclusion
On a démontré que, dans le pire des cas, la mise à jour d’un arbre de plus courts chemins quand une
unique arête était modifiée est en temps Ω(n · log(n)) dans le cadre des arbres dynamiques. En admettant
que la structure de grove (cf. 3.2.3) est la meilleure pour résoudre le problème de la recherche du prochain
pivot pour un graphe plongé sur une surface de genre g, on obtient même Ω(g · n · log(n)). Ainsi, la mise à
jour de Ω(g) arbres de plus courts chemins nous donne immédiatement une complexité en Ω(g 2 · n · log(n))
qui n’est pas meilleure que celle de l’algorithme statique de Cabello et Erickson [2]. Le problème du calcul
du plus court cycle non-contractile dispose de plusieurs algorithmes et est à l’heure actuelle bien étudié
[3, 12, 14]. L’approche dynamique, pourtant naturelle, ne semble pas apporter d’efficacité compte tenu
des résultats de cette étude puisqu’elle ne permet pas d’obtenir une meilleure complexité que la simple
répétition des algorithmes statiques. On notera cependant que l’utilisation de découpages successifs (cf.
1.2.2) nous donne des résultats plus encourageants. Nous avons montré qu’un plus court chemin n’est
transformé qu’en deux plus courts chemins au plus quand on modifie le poids d’une unique arête (théorème
5). Ce résultat nous permet de tirer avantage des informations obtenues avant la modification du graphe
en conservant les mêmes découpages. Cette remarque ne permet pourtant pas d’obtenir un algorithme
suffisamment efficace car tous les algorithmes considérés nécessitent la mise à jour de Ω(g) arbres de plus
courts chemins. Enfin, les arbres de recouvrements comme les arbres de plus courts chemins semblent
incontournables pour la recherche du plus court cycle non-contractile. L’étude dynamique de ces arbres
nécessite l’utilisation des arbres dynamiques et dans ce cadre, il n’a pas été possible de construire un
algorithme réalisant une mise à jour plus rapidement que les algorithmes statiques.
Références
[1] Baswana, S., Hariharan, R., and Sen, S. Improved decremental algorithms for maintaining
transitive closure and all-pairs shortest paths. In Proceedings of the thiry-fourth annual ACM symposium on Theory of computing (New York, NY, USA, 2002), STOC ’02, ACM, pp. 117–123.
[2] Cabello, C. e. E. Multiple-source shortest paths in embedded graphs.
[3] Cabello, S., Colin de Verdière, ı., and Lazarus, F. Algorithms for the edge-width of an
embedded graph. Comput. Geom. Theory Appl. 45, 5-6 (July 2012), 215–224.
[4] Chan, T. M. More algorithms for all-pairs shortest paths in weighted graphs. In Proceedings of the
thirty-ninth annual ACM symposium on Theory of computing (New York, NY, USA, 2007), STOC
’07, ACM, pp. 590–598.
19
[5] Cormen, T. H., Leiserson, C. E., Rivest, R. L., and Stein, C. Introduction à l’algorithmique.
2004 (seconde édition).
[6] Demetrescu, and Italiano. Fully dynamic all pairs shortest paths with real edge weights.
[7] Demetrescu, C., and Italiano, G. F. A new approach to dynamic all pairs shortest paths. J.
ACM 51, 6 (Nov. 2004), 968–992.
[8] Eppstein, D. Dynamic generators of topologically embedded graphs. In Proceedings of the fourteenth
annual ACM-SIAM symposium on Discrete algorithms (Philadelphia, PA, USA, 2003), SODA ’03,
Society for Industrial and Applied Mathematics, pp. 599–608.
[9] Erickson, J. Shortest non-trivial cycles in directed surface graphs. In Proceedings of the 27th
annual ACM symposium on Computational geometry (New York, NY, USA, 2011), SoCG ’11, ACM,
pp. 236–243.
[10] Erickson, J., and Har-Peled, S. Optimally cutting a surface into a disk. In Proceedings of the
eighteenth annual symposium on Computational geometry (New York, NY, USA, 2002), SCG ’02,
ACM, pp. 244–253.
[11] Erickson, J., and Whittlesey, K. Greedy optimal homotopy and homology generators. In
Proceedings of the sixteenth annual ACM-SIAM symposium on Discrete algorithms (Philadelphia,
PA, USA, 2005), SODA ’05, Society for Industrial and Applied Mathematics, pp. 1038–1046.
[12] Erickson, J., and Worah, P. Computing the shortest essential cycle. Discrete & Computational
Geometry 44 (2010), 912–930.
[13] Federickson, G. N. Fast algorithms for shortest paths in planar graphs, with applications. SIAM
Journal on Computing 16, 6 (1987), 1004–1022.
[14] Fox, K. Shortest non-trivial cycles in directed and undirected surface graphs.
[15] Italiano, G. F., Nussbaum, Y., Sankowski, P., and Wulff-Nilsen, C. Improved algorithms
for min cut and max flow in undirected planar graphs. In Proceedings of the 43rd annual ACM
symposium on Theory of computing (2011), ACM, pp. 313–322.
[16] Lazarus, F., Pocchiola, M., Vegter, G., and Verroust, A. Computing a canonical polygonal
schema of an orientable triangulated surface. In Proceedings of the seventeenth annual symposium
on Computational geometry (New York, NY, USA, 2001), SCG ’01, ACM, pp. 80–89.
[17] Mohar, B., and Thomassen, C. Graphs on Surfaces. Johns Hopkins Studies in the Mathematical
Sciences. Johns Hopkins University Press, 2001.
[18] Sleator, D. D., and Tarjan, R. E. Self-adjusting binary search trees. J. ACM 32, 3 (July 1985),
652–686.
[19] Stillwell, J. Classical Topology and Combinatorial Group Theory. Graduate Texts in Mathematics.
Springer, 1993.
[20] Tarjan, R. E. Data Structures and Network Algorithms. SIAM, 1983.
[21] Tarjan, R. E. Dynamic trees as search trees via euler tours, applied to the network simplex
algorithm. Mathematical Programming 78 (1997), 169–177.
[22] Tarjan, R. E., and Werneck, R. F. Self-adjusting top trees. In Proceedings of the sixteenth
annual ACM-SIAM symposium on Discrete algorithms (Philadelphia, PA, USA, 2005), SODA ’05,
Society for Industrial and Applied Mathematics, pp. 813–822.
[23] Tarjan, R. E., and Werneck, R. F. Dynamic trees in practice. J. Exp. Algorithmics 14 (Jan.
2010), 5 :4.5–5 :4.23.
[24] Thorup, M. Worst-case update times for fully-dynamic all-pairs shortest paths. In Proceedings of
the thirty-seventh annual ACM symposium on Theory of computing (New York, NY, USA, 2005),
STOC ’05, ACM, pp. 112–119.
20