Théorie et algorithmique des graphes - LINMA1691Rapport de projet - Les graphes évolutifs

Professeur titulaireVincent Blondel

AuteursHadrien Van LierdePatrick Lambert

Pierre-Alexandre Beaufort

Décembre 2012

Table des matières

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ii1 Notions de graphes évolutifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1.1 Les rudiments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2 Voyager dans le temps . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.3 Les arbres évolutifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 Le plus court chemin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42.1 Hypothèses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42.2 Algorithmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

3 Connexité à travers le temps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73.1 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73.2 Vérifier la connexité forte . . . . . . . . . . . . . . . . . . . . . . . . . . 83.3 Identifier les composantes connexes . . . . . . . . . . . . . . . . . . . . . 9

4 Arbre de recouvrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104.1 Optimalité d’un arbre de recouvrement . . . . . . . . . . . . . . . . . . . 114.2 Trouver un arbre de recouvrement : un problème NP difficile . . . . . . . 114.3 Algorithme de l’arbre de recouvrement minimum . . . . . . . . . . . . . 12

5 Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155.1 LEO Satellites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155.2 Les interactions sociales . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . I

Annexes IIA Implémentations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . III

A.1 Le plus court chemin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . IIIA.2 L’arbre de recouvrement minimum . . . . . . . . . . . . . . . . . . . . . X

Bibliographie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XIX

i

IntroductionNotre société est en perpétuelle évolution.

L’illustration de la page de garde en est une preuve. Elle met en scène un réseau de satellitesen orbite, interagissant avec des systèmes terrestres de communication ; il s’agit des LEO Satel-lites. Ce support de communication a été instauré afin de permettre la diffusion d’informationsà travers le monde, ce qui est devenu primordial dans notre société. D’ailleurs, la technologietend de plus en plus à favoriser l’accès et l’échange d’informations via des systèmes wireless etmobiles.

La théorie des graphes est une excellente piste pour la modélisation de ces situations. Tou-tefois, les graphes représentant ces objets devront exprimer le caractère mobile de la situation,tout en soulignant les interactions au cours du temps. On devine que ces graphes devront évo-luer au cours du temps, suivant les transformations dynamiques qu’ils subissent. Ce type degraphe s’appelle “Graphe évolutif ”.

L’objet de ce rapport est de définir les graphes évolutifs et les notions fondamentales qui ysont liées et d’ensuite développer l’ensemble des outils nécessaires pour effectuer une analyse to-pologique de ces graphes : pour chaque problème (plus court chemin, arbre de recouvrement...),nous donnons soit un algorithme de résolution en temps polynomial, soit une démonstration deNP-complétude ou NP-difficulté. La structure de ce rapport est la suivante.

Tout d’abord, nous présentons les notions propres aux graphes évolutifs, sans négliger leurdéfinition formelle. Ce formalisme nous permettra de faire le contraste entre les graphes sta-tiques et les graphes dynamiques.

Ensuite, nous considérons le problème de véhiculer le plus rapidement possible une informa-tion. Ce problème est exprimé par celui du plus court chemin dans un graphe dynamique. Onétablira les algorithmes qui permettent de construire des plus courts chemins qui conserventl’information par hypothèse, puisque c’est notre souhait.

Par après, il est logique de discuter des zones où l’information, émanant d’un objet, peutvéhiculer afin d’évaluer l’influence de l’information. Ce paramètre est décrit au moyen de laconnexité à travers le temps. Dans notre analyse, nous présentons d’abord une méthode pourdéterminer si un graphe est connexe ou non, puis nous analysons le problème de la détermina-tion des composantes connexes d’un graphe.

Par la suite, nous nous intéressons aux structures graphiques qui permettent à l’informa-tion émise par un objet d’être diffusée à un maximum d’objets et ce pour un coût minimal (ouune dépense d’énergie minimale). Plus particulièrement, nous étudierons celles qui minimisentleur complexité spatiale, à savoir les arbres de recouvrement minimum. En plus de donnerl’algorithme permettant d’obtenir ce type de structure dans certains cas particuliers, nous ana-lyserons les difficultés rencontrées pour trouver un arbre de recouvrement minimum dans le casgénéral.

Enfin, nous clôturons ce rapport par deux exemples d’application : les LEO satellites et lesInteractions Sociales. Dans chaque cas, des informations sont manipulées au cours du temps.

ii

1 Notions de graphes évolutifs [3]Dans cette section, nous réalisons une première approche de la notion de graphe évolutif.

Cette approche permet de mieux appréhender les concepts abordés dans les sections suivantes.Ainsi, nous présentons dans un premier temps les notions élémentaires liées au caractère dyna-mique des graphes évolutifs. Ensuite, nous introduisons un nouveau concept, celui de voyageau sein d’un graphe temporel. Enfin, nous voyons ce qu’il advient des arbres dans le cas degraphes évolutifs

1.1 Les rudimentsLa notion de graphe évolutif permet la formalisation du concept de graphe à travers le

temps. Cette formalisation permet de représenter de manière abstraite et efficace les réseauxdynamiques qui sont aujourd’hui nombreux - voire omniprésents - dans notre société moderne.

Grossièrement, la notion de graphe évolutif peut être décrite comme une succession de sous-graphes au cours du temps. Chaque sous-graphe correspond à un intervalle de temps. Nousdéfinissons donc une séquence de temps de présence d’une arête ainsi qu’une séquence de tempsde présence d’un sommet.

Définition 1.1 (Séquence de temps de présence d’une arête (respectivement, d’un sommet)).Ce qui indique les instants durant lesquels l’arête (respectivement, le noeud) est présent(e). Ilest possible d’ajouter les différentes caractéristiques de l’arête (respectivement, le noeud) durantces intervalles.

Maintenant, nous pouvons formuler une définition plus formelle de graphe évolutif.

Définition 1.2 (Graphe évolutif). Soient un graphe G(V,E) et une séquence ordonnée de sessous-graphes, SG = G1, G2, ..., GT tel que ∪Ti=1Gi = G. Soit une séquence ordonnée d’instantsST = t0, t1, ..., tT . Alors, l’ensemble G = (G,SG, ST ), où chaque Gi est le sous-graphe présentdurant [ti−1; ti[, est un graphe évolutif. Nous notons |V | = N et |E| = M . On pose VG = V etEG = E.

La définition G = (G,SG, ST ) détermine G de façon univoque. Toutefois, pour alléger lesnotations utilisées dans les démonstrations, nous définissons G = (VG, EG), en supposant connusles pas de temps durant lesquels chaque arête est active.

Dès lors, nous pouvons définir quelques caractéristiques en lien avec l’activité et la dyna-mique d’un graphe évolutif.

Définition 1.3 (Activité d’un sommet v (respectivement, d’une arête e)). Le nombre d’inter-valles de présence du sommet v (respectivement, arête e), noté δV (v) (respectivement, δE(e)).

Définition 1.4 (Activité sommet (respectivement, arête)). Le maximum de l’activité des som-mets (respectivement, arêtes), noté δV (respectivement, δE) tel que :

δV = max(δV (v))|v ∈ VG(respectivement, δE = max(δE(e))|e ∈ EG)

Définition 1.5 (Activité d’un graphe évolutif). Le maximum entre l’activité sommet et l’acti-vité noeud, noté δ tel que :

δ = max(δV , δE)

Définition 1.6 (Dynamique d’un graphe évolutif). Défini par la relation δ−1T, où T est le

nombre de sous-graphes au cours du temps.

1

1.2 Voyager dans le tempsDans les graphes traditionnels, on étudie généralement les types de chemins que l’on peut

effectuer en leur sein. Il est donc utile de développer le concept de chemin pour un graphe évolu-tif, c’est-à-dire un chemin à travers le temps. Nous analyserons ensuite brièvement la notion deplus court chemin dans un graphe évolutif. Celle-ci sera développée davantage dans le chapitre 2

Le bon sens nous amène à considérer les chemins temporels qui progressent à travers letemps. Ce concept est celui du voyage dans un graphe évolutif.

Définition 1.7 (Voyage). Soit un chemin R = e1, e2, ..., ek où ei ∈ EG. Soit Rσ = σ1, σ2, ..., σk,un instant indiquant que l’arête ei est parcourue au temps σi. Dès lors, J est un voyage si etseulement si Rσ est en concordance avec R et G, c’est-à-dire si J permet la traversée de u à vau sein de G au cours du temps.

En général, nous souhaitons minimiser un voyage, de telle sorte qu’il soit le plus courtpossible. Toutefois, on peut optimiser un voyage selon différents critères. En effet, on peutminimiser soit le temps auquel le voyage s’achève, soit le nombre d’arêtes parcourues ou soitla durée du voyage. Ces trois optimisations s’appellent - respectivement - les premiers, lesmin-sauts et les plus rapides voyages.

Les premiers voyages

Il s’agit des voyages qui arrivent le plus tôt possible à tous les sommets du graphes enpartant d’un noeud source s.L’algorithme de Dijkstra semble être une méthode correcte de minimisation, étant donné qu’ilconstruit un ensemble S de manière itérative. Cet ensemble contiendra au final tous les sommetsdu graphe, puisqu’on ajoute un à un les différents sommets. Avant l’ajout d’un sommet v /∈ S,on calcule la distance d(v∗) entre u et ses sommets voisins v ; ensuite, si d(v∗) + d(u) < d(v),où d(u) est la distance entre u et le sommet s de référence et où d(v) est la distance entre s etcertains v notés v, alors la distance d(v) est mise à jour. On constate que l’algorithme se basesur le fait que les chemins les plus courts sont eux-mêmes composés de chemins les plus courts.

Néanmoins, la transposition fidèle de l’algorithme au cas évolutif ne fonctionne pas. En effet,les premiers voyages ne sont pas forcément composés de premiers voyages. Toutefois, il existeau moins un premier voyage qui présente cette propriété. Il est donc possible de concevoir unalgorithme qui détermine ce type de voyage optimisé (cf. section 2).

Les min-sauts voyages

L’objectif est de minimiser le nombre d’arêtes parcourues.Comme précédemment, les min-sauts voyages ne sont pas forcément composés de min-sautsvoyages. Toutefois, une propriété se dégage. Notons (u; v), la dernière arête d’un min-sautvoyage s’effectuant du sommet s au sommet v et arrivant au temps t. Si une telle arête existe,alors ce min-saut voyage est plus court que tous les voyages s’effectuant de s à u et s’achevantavant t.

Dès lors, on considère tous les couples (u; t), pour lesquels on calcule les min-sauts voyagesde s à u existant avant le temps t. De cette manière, nous pouvons construire un arbre illustrantles différents voyages de s aux couples (u; t). A partir de cet arbre, nous pouvons déterminerl’ensemble des min-sauts voyages de s à u, étant donné que chaque sommet u apparaît au moins

2

une fois dans l’arbre construit pour autant qu’un voyage existe de s à u.

La complexité de l’algorithme (d’après l’article [3]) est O(MdlogδE) si G est connexe, où dest l’excentricité de s. Si G n’est connexe, alors la complexité est de O(NMlogδE) .

Les plus rapides voyages

Nous souhaitons minimiser la durée du voyage.Atteindre l’objectif n’est pas simple. D’une part, il est possible qu’un voyage plus rapide appa-raisse au cours du temps. D’autre part, la durée d’une partie d’un voyage ne détermine pas ladurée du voyage tout entier. De fait, une attente prolongée en un sommet peut être avantageuse,si elle est rentable par rapport au gain de temps obtenu lors du parcours des arêtes.

L’algorithme procède saut par saut, dont le nombre k est borné par N . Pour toute valeur kpossible, on constitue une liste des voyages de longueur k, démarrant d’un sommet s. Cette listeest construite à partir de celle des voyages constitués de k−1 sauts. De fait, on étend chacun deces voyages à k sauts, c’est-à-dire en leur ajoutant une arête. Pour ce faire, on examine chaquearête du graphe évolutif, afin de déterminer les voyages étendus qui peuvent contenir l’arêtecourante. Ces voyages constituent la liste des voyages de k sauts. La N -ième liste contient lesvoyages de N sauts, parmi lesquels certains sont des “plus rapides” voyages. Dès lors, il suffirade les identifier au sein de la liste. La complexité de cet algorithme (d’après l’article [3]) estbornée à O(NM2δE).

1.3 Les arbres évolutifsLa notion d’arbre évolutif n’est pas aisée à développer étant donné qu’il est difficile d’ex-

primer la connexité d’un graphe évolutif. Nous exprimons cette notion d’une manière prochede celle d’un arbre de recouvrement traditionnel, étant donné qu’on souhaite souligner le faitqu’un arbre est une structure qui minimise la connexité d’un graphe. Pour ce faire, il nous fautdéfinir ce qu’est un sous-graphe évolutif.

Définition 1.8 (Sous-graphe évolutif). Soit un arbre évolutif G = (G,SG, ST ). Le graphe évo-lutif G ′ = (G′, S ′G, S ′T ) est un sous-graphe évolutif de G, si G′ est un sous-graphe de G et s’ilexiste une fonction monotone f : N→ N tel que pour tout i, G′i est un sous-graphe de Gf(i) et[ti−1; ti[⊂ [tf(i−1); tf(i)[.

Dès lors, on peut définir l’homologue temporel de l’arbre de recouvrement.

Définition 1.9 (Arbre évolutif de racine r dans un graphe évolutif G). Soit un sommet s ∈ V .Un arbre évolutif de racine r dans un graphe évolutif G est un sous-graphe évolutif Gr ⊂ G :

– tel que Gr est un arbre ;– tel que chaque arête a exactement un intervalle de présence ;– tel qu’il existe un voyage de r à chaque sommet de l’arbre.

On dit que l’arbre évolutif de racine r est un arbre de recouvrement s’il contient tous lessommets de V .

Par conséquent, un arbre évolutif de racine r minimise la complexité spatiale du graphe,étant donné que l’arbre permet la diffusion à partir de r via des arêtes d’activité unitaire.Ainsi, un arbre évolutif de racine r permet de définir le temps de diffusion d’informationsdans le graphe évolutif qu’il recouvre. C’est pertinent, puisque ce type d’arbre est composé depremiers voyages. Finalement, il est évident que le graphe qui en contient un autre a un coûtplus important que celui de son contenu.

3

2 Le plus court chemin [2]Nous venons de définir les concepts liés aux parcours dans un graphe évolutif. Nous avons

notamment vu qu’un chemin d’un sommet à un autre nécessite un voyage dans l’espace et dansle temps, car les arêtes parcourues ne sont pas nécessairement activées pendant toute la duréedu parcours. Nous avons également vu qu’il existait deux manières d’optimiser un parcoursd’un sommet à un autre : soit on souhaite minimiser la durée du trajet, soit on souhaite quel’information arrive le plus tôt possible à destination (le min-saut voyage est un cas particulierdu voyage le plus rapide) 1. Les solutions de ces deux problèmes sont implémentées par desalgorithmes différents. Dans ce chapitre, nous établissons un algorithme calculant à partir d’unsommet le plus court chemin (en durée) vers chacun des autres sommets. Nous confirmeronsque l’algorithme de Dijkstra ne peut pas être utilisé dans le cas évolutif.

L’utilité du calcul du chemin le plus rapide transparaît dans l’application suivante. Le réseaudu transport aérien mondial peut être perçu comme un vaste graphe évolutif dont les sommetssont les aéroports et les arêtes sont les vols. Comme il n’est pas possible de prendre un avionà n’importe quel moment, il s’agit bien d’un graphe évolutif. Lorsqu’un voyageur cherche àse rendre d’un aéroport à un autre, le rôle de son agence de voyage est de trouver le trajetle plus rapide entre les deux villes 2. Plus les deux villes sont éloignées et moins les aéroportssont importants, plus le voyage nécessite d’escales. L’agence est donc amenée à trouver le pluscourt chemin entre le point de départ et la destination dans un graphe évolutif. Elle devra tenircompte des heures de départ et de la durée totale de chaque vol pour assurer au voyageur qu’ilaura le temps de passer d’un vol à l’autre.

2.1 HypothèsesAvant d’élaborer un algorithme du plus court chemin, plusieurs hypothèses peuvent être

formulées à propos des caractéristiques d’un graphe évolutif. Ces différents scénarios donnentlieu à des algorithmes spécifiques, nous en décrivons trois dans cette section.

Dans chaque algorithme, nous associons à chaque sommet une liste d’adjacence, c’est-à-direune liste donnant l’ensemble des voisins de ce sommet et les pas de temps où ceux-ci sontconnectés. Pour plus de clarté, nous considérerons que le calcul du plus court chemin consisteà transporter une information d’un sommet à tous les autres sommets en un temps minimal.Les différences entre les scénarios décrits ci-dessous portent sur les deux points suivants :

– le nombre de pas de temps mis par une information pour traverser une arête (le coût del’arête)

– ou le nombre d’arêtes qui peuvent être traversées en un pas de temps.

2.2 AlgorithmesIntervalle de présence unitaire

Nous émettons les hypothèses suivantes :– les coûts (nombre de pas de temps pour traverser une arête) valent tous 1 ;– il y a conservation de l’information : si un sommet disparaît et réapparaît ensuite, ilcontient toujours les informations reçues précédemment ;

1. Nous ne traiterons pas le cas de la minimisation du coût du trajet (en connaissant le coût de chaquearête).

2. En pratique, il est également question de coût des billets d’avion. Mais nous ne considérerons pas ce cas.

4

– l’information ne peut traverser plus d’une arête en un même pas de temps ;

L’algorithme se décrit de la façon suivante :On cherche itérativement le plus court chemin de a vers chacun des autres sommets. On insèreles sommets au fur et à mesure qu’ils sont parcourus dans un arbre de plus court chemin.

Algorithme 2.1.

1. Initialiser les distances : d(a) = 0 et d(v) = ∞ ∀v 6= a. Initialiser Q, une liste classéepar ordre croissant de la racine root(Q) au sommet : Q = (φ, d(φ) = ∞)|(a, d(a) = 0).Initialiser i à 0 (i représente l’évolution des pas de temps)

2. While d(root(Q)) 6=∞ do(a) While d(root(Q)) = i do

i. Extraire x, le sommet à root(Q)ii. Supprimer root(Q)iii. Parcourir la liste d’adjacence de x, et pour tout voisin v calculer fa(v) (le premier

temps supérieur ou égal à i+1 où v est accessible à partir de x)iv. Insérer v dans Q s’il n’y était pas déjàv. Si fa(v) < d(v) alors mettre à jour d(v) avec fa(v) et mettre à jour la position

de v dans Q.vi. Fermer x, l’insérer dans l’arbre de plus court chemin.

(b) Passer au pas de temps suivant : i← i+ 1

La variable fa(v) indique le premier pas de temps où le sommet a peut transmettre soninformation au sommet v. Par conséquent, si en un sommet x, on obtient pour un voisin v,fa(v) > i+ 1, l’information stationne en x pendant un temps fa(v)− (i+ 1) avant d’être trans-mise à v.

La complexité de cet algorithme est la suivante. Soient N le nombre de sommets, M lenombre d’arêtes et T le nombre de pas de temps. Pour un sommet v, on parcourt ses d+(v)voisins, on détermine pour chacun le premier pas de temps où il est connecté à v et enfinon l’introduit dans Q en respectant l’ordre de classement des sommets dans Q. Pour chaquesommet v, si on utilise un algorithme de recherche efficace, cela demande O(log(T ) + log(N))opérations. Le nombre total d’opérations est donc O(∑

v∈V d+(v)(log(T ) + log(N))) ou encore

O(M(log(T ) + log(N))).

Nous avons implémenté l’algorithme en utilisant le langage JAVA. Le code et la descriptionde chaque classe sont fournis en annexe. Le programme principal (cf. Implémentations A.1)fonctionne comme suit. Les sommets du graphe sont numérotés de 0 à N − 1. Les paramètresdu programme sont le numéro du sommet racine (à partir duquel on détermine les chemins) etun tableau contenant pour chaque sommet la liste de ses voisins et la liste des pas de tempsdurant lesquels ils sont connectés. Le programme renvoie une liste chaînée contenant chaquesommet, le pas de temps durant lequel il reçoit l’information et le sommet qui lui transmetl’information. Pendant que le programme est en cours d’exécution, une liste chaînée Q reçoitou perd des sommets à chaque itération (conformément à la description de Q dans l’algorithme2.1). L’implémentation a nécessité la définition de plusieurs classes (outre celle résolvant leproblème) : des classes permettant la création et l’utilisation des listes chaînées et une classe

5

définissant un sommet dans l’arbre de plus court chemin (on lui associe trois variables d’ins-tance : son label, le temps où il reçoit l’information et le sommet qui lui transmet l’information).

Ci-dessous, nous donnons un graphe (celui de gauche) ainsi que son arbre de plus courtchemin (celui de droite) en partant du noeud 1. Les chiffres à côtés de chaque arête représententles pas de temps durant lesquels cette arête est active. Ce graphe peut représenter un réseaud’aéroports (par exemple à l’échelle d’un pays) utilisé par une agence de voyage pour déterminerle premier trajet permettant d’aller de l’aéroport 1 à un autre aéroport.

1

2 3

4 5

1 2

2

3

45

3

1

2 3

4 5

1 2

2 4

Cet algorithme peut être étendu pour des cas plus généraux décrits ci-après.

Parcourir plusieurs arêtes en un pas de temps

Relaxons légèrement le problème précédent en permettant à une information de traverserk arcs en un pas de temps. C’est le cas lorsque le temps mis par l’information pour traverserune arête est court par rapport à la durée de vie de l’arête. On observe cela notamment dans ledomaine de la communication entre satellites LEO (dont nous reparlerons dans la section 5).On modifie l’algorithme 2.1, en associant à chaque sommet v visité une variable n donnant lenombre d’arêtes visitée avant v au cours d’un même pas de temps. Tant que cette variable vn’a pas atteint k, il est toujours possible d’atteindre un autre sommet au cours du même pas detemps. Concrètement, cela signifie qu’on change seulement les points suivants dans l’algorithmedu plus court chemin :

Algorithme 2.2.

1. Initialiser n(v) = 0∀v ∈ V et Q = (dummy, d(dummy) = ∞, n(dummy) = 0)|(a, d(a) =0), n(a) = 0)

2. on ne modifie que les points 2(a)iii et 2(a)iv de l’algorithme 2.1 : pour tout voisin v de x,on calcule fa(v) de la façon suivante et on met ensuite à jour d(v), key(v) et n(v) :– Si n(x) < k alors on cherche fa(v), le premier temps supérieur ou égal à i, où x et vsont connectés. On met à jour les autres variables : si fa(v) < d(v) alors on met à jourd(v) avec fa(v) et n(v) avec n(x) + 1. Enfin, on met à jour la position de v dans Q.

– Si n(x) = k alors on cherche fa(v), le premier temps supérieur ou égal à i+ 1, où x etv sont connectés. On met à jour les autres variables : si fa(v) < d(v), alors mettre àjour d(v) avec fa(v) et n(v) avec 1. Enfin, on met à jour la position de v dans Q.

La complexité de l’algorithme 2.2 est identique à celle de l’algorithme 2.1. L’implémentationne demande qu’une modification mineure du programme précédent A.1.

6

Parcourir une arête en plusieurs pas de temps

Supposons à présent que parcourir une arête prenne un nombre entier de pas de temps,noté c(u, v). Il faut donc veiller à ce qu’aucune arête ne disparaisse lorsqu’une information laparcourt. En pratique, cette situation reflète mieux le travail d’une agence de voyage que l’al-gorithme 2.1 car il tient compte du fait que la durée de chaque vol peut-être différente.

On étend l’algorithme 2.1 en apportant les modifications suivantes :

Algorithme 2.3.

1. Initialisation : si, dans la liste d’adjacence d’un sommet, la connexion avec un voisindure un laps de temps inférieur au coût de l’arête qui les connecte, alors on supprimecette connexion de la liste d’adjacence.

2. On ne modifie que les points 2(a)iii et 2(a)iv de l’algorithme 2.1. Pour tout voisin v de x,on met à jour d(v) de la façon suivante : on cherche un intervalle de temps [f−a (v); f+

a (v)],où v et x sont connectés et qui réalise minf−a (v) tel que f−a (v) ≥ i+ 1 et f+

a (v)−f−a (v) ≥c(u, v). Si on trouve un tel intervalle de temps, alors on met à jour les autres variables :Si f−a (v) + c(u, v) < d(v) alors mettre à jour d(v) avec f−a (v) + c(u, v). Enfin, on met àjour la position de v dans Q.

La complexité de l’algorithme 2.3 est identique à celle de l’algorithme 2.3 (L’étape d’initia-lisation ne demande qu’un temps O(M)).. L’implémentation ne demande qu’une modificationmineure du programme précédent (cf. Implémentations A.1) : en traversant une arête, l’infor-mation n’atteint pas le sommet destinataire un pas de temps plus tard, mais bien un tempsfixé c(u, v) plus tard.

3 Connexité à travers le tempsDans cette section, nous définissons d’abord les concepts liés à la connexité dans le cas

dynamique. Ensuite, nous voyons comment vérifier la connexité forte d’un graphe évolutif.Enfin, nous discutons de la procédure qui identifie les composantes connexes à travers le temps.

3.1 Définitions [3]On se souvient que la connexité dans un graphe traditionnel s’exprime par le fait qu’on

peut atteindre à partir de n’importe quel sommet du graphe, tous les autres sommets de cemême graphe. Cependant, dans un graphe évolutif, la notion de connexité se complexifie vule caractère dynamique de la géométrie du graphe. Par conséquent, on préférera parler deconnexité-temporel.

Définition 3.1 (Connexité-temporel). Un graphe évolutif est connexe-temporel, s’il existe desvoyages dans G pour tout couple de sommets de VG.

Par abus de langage, nous appellerons graphe évolutif fortement connexe tout grapheconnexe-temporel.

Généralement, nous souhaitons avoir la plus grande composante connexe d’un graphe évo-lutif. De fait, imaginons un projet sur lequel deux compagnies travaillent en partenariat. Lescompagnies souhaitent voir un maximum de ses employés collaborer les uns avec les autres,aussi bien inter que intra compagnie. Cette collaboration peut être directe ou indirecte, c’est-à-dire qu’un employé travaille soit directement avec les autres, soit il ne travaille pas directement

7

avec certains employés, mais alors il travaille avec des employés qui eux travaillent directementou indirectement avec ces employés. Evidemment, un employé ne peut pas travailler simulta-nément avec tout le monde étant donné les horaires variés des employés. Cette situation peutêtre représentée au moyen d’un graphe évolutif, où les sommets représentent les employés desdeux compagnies et les arêtes signifient que les employés correspondant travaillent directe-ment durant l’intervalle de présence de l’arête. Le souhait des compagnies de voir l’interactionmaximisée consiste en la composante maximale connexe-temporel.

Définition 3.2 (Composante maximale connexe-temporel (MTCC)). Ensemble reprenant unmaximum de sommets UG ⊆ VG, tel que pour toute paire u, v ∈ UG, il existe un voyage de u àv et un voyage de v à u, en utilisant uniquement des sommets UG.

Par abus de langage, nous parlerons de composante fortement connexe d’un graphe évolutifpour désigner une composante connexe maximale de ce graphe.

Maintenant, imaginons qu’une des deux entreprises souhaite mettre en évidence la collabo-ration directe et indirecte de ses propres employés. Dès lors, on considère que la collaborationindirecte peut s’effectuer via des employés de l’autre entreprise. Cette mise en évidence corres-pond à la composante maximale ouverte connexe-temporel de l’ensemble des employés des deuxcompagnies restreint à une des deux compagnies.

Définition 3.3 (Composante maximale ouverte connexe-temporel (o-MTCC)). Ensemble re-prenant un maximum de sommets UG ⊆ VG, tel que pour toute paire u, v ∈ UG, il existe unvoyage de u à v et un voyage de v à u utilisant uniquement des sommets de VG.

On constate qu’il y a deux types de composante maximale connexe à travers le temps, ce quin’existe pas dans le cas statique. Dans les sous-sections 3.2 et 3.3, nous nous intéressons à deuxproblèmes liés à la connexité : prouver qu’un graphe évolutif est fortement connexe et trouverl’ensemble de ses composantes fortement connexes maximales. Contrairement au cas statique,ces deux problèmes ne peuvent être traités simultanément, car le premier peut être résolu en untemps polynomial, alors que le second est NP-complet. Nous n’avons pas analysé le problèmede la détermination des composantes connexes temporelles ouvertes, mais une démonstrationplus générale montre qu’il s’agit également d’un problème NP-complet.

3.2 Vérifier la connexité forte [1]Proposition 3.1. Soit un graphe évolutif G composé de N nœuds et M sommets, défini sur uneséquence ordonnée de T instants. Il existe un algorithme de complexité O(NM(log(N)+log(T ))démontrant si ce graphe est fortement connexe ou non.

Démonstration Pour chaque sommet du graphe, on applique l’algorithme du plus courtchemin de complexité O(M(log(N) + log(T )). Si à partir de chaque sommet, tous les autressommets sont accessibles, le graphe est fortement connexe. La complexité de cet algorithme estde O(NM(log(N) + log(T ))).

Illustrons cette proposition par une application. Revenons au problème du voyageur en avion(exposé à la section 2). On peut vérifier en un temps polynomial si le graphe évolutif formé parl’ensemble des aéroports et des vols est fortement connexe. Si c’est le cas, à partir de n’importequel aéroport, le voyageur peut effectuer un parcours de l’ensemble des aéroports en ne passantqu’une seule fois par chaque aéroport. Si le graphe n’est pas fortement connexe, il est intéressantpour le voyageur de connaître les composantes fortement connexes. Nous démontrons que ceproblème est NP-complet.

8

3.3 Identifier les composantes connexes [1]Dans le cas statique, il existe un algorithme polynomial pour déterminer l’ensemble des

composantes fortement connexes d’un graphe orienté. A partir d’un sommet v, on effectue uneexploration du graphe (en largeur ou en profondeur) et on note l’ensemble V1 des sommetsaccessibles à partir de v. Ensuite, on inverse le sens de chaque arête du graphe et on effectue ànouveau une exploration du graphe à partir de v et on note V2 l’ensemble des sommets à partirdesquels on peut accéder à v. V1 ∩ V2 est une composante fortement connexe du graphe. Oncomprend facilement que cet algorithme n’est pas généralisable au cas des graphes évolutifs,car les arêtes ne sont pas toutes actives durant les mêmes intervalles de temps. Ainsi, s’il existeun voyage d’un sommet v à un sommet u dans un graphe G, il n’existe pas forcément un voyagede u à v dans le graphe formé en inversant le sens de chaque arête de G et en conservant lesmêmes séquences de temps de présence.

Pour démontrer que ce problème est NP-complet, on démontre qu’un problème de déci-sion P1 est NP-complet, avec P1 définit de la façon suivante : étant donné un graphe évolutifG = (VG, EG) et un entier k, existe-t-il une composante fortement connexe de G contenant ksommets ?

Théorème 3.1 (P1 est dans NP). P1 est dans NP c’est-à-dire qu’étant donné un sous-graphede G = (VG, EG), on peut déterminer en un temps polynomial si ce sous-graphe est solution deP1.

Démonstration : La vérification est immédiate. Soit G ′ = (V ′G, E ′G) un candidat de solutionde P1 avec V ′G un sous-ensemble de l’ensemble VG des sommets de G et E ′G l’ensemble des arêtesde EG liant deux sommets de V ′G. On vérifie en un temps polynomial que |V ′G| = k. Ensuite,comme dans le cas de la démonstration de la proposition 3.1, on démontre en utilisant un al-gorithme polynomial si G ′ est bien fortement connexe. Enfin, pour chaque sommet v ∈ VG\V ′G,on construit un graphe à partir de G ′ en lui ajoutant le sommet v et toutes les arêtes liant v àun sommet de V ′G ; on démontre ensuite en utilisant l’algorithme polynomial du plus court che-min que chacun de ces graphes n’est pas fortement connexe. G ′ est donc bien une composantefortement connexe maximale de G.

Nous définissons le graphe d’accessibilité de G comme un graphe non dirigé AG = (VA, EA)avec VA = VG et EA contenant l’ensemble des arêtes (vi, vj) de EG telles qu’il existe un voyagedans G de vi à vj et de vj à vi. Nous définissons également un nouveau problème P2 : étantdonné un graphe statique non orienté G = (V,E), existe-t-il une clique contenant k sommetsdans G ?

Lemme 3.1 (Equivalence des problèmes). Les deux problèmes suivant sont équivalents : existe-t-il une composante fortement connexe contenant k sommets dans G et existe-il une cliquecontenant k sommets 3. (sachant que le problème P2 est NP complet 4).

Démonstration : ceci découle directement de la définition d’AG, s’il existe une clique dansAG alors, dans G, il existe un voyage entre chacun des sommets de cette clique et vice-versa.

3. Nous définissons une clique maximale d’un graphe G comme un sous-graphe complet de taille maximalede G.

4. Professeur Vincent BLONDEL, LINMA1691, cours magistral

9

Lemme 3.2. P2 peut être ramené à P1 en un temps polynomial.

Démonstration : Dans cette démonstration, nous cherchons à résoudre le problème P2 surun graphe statique G. En suivant un algorithme établi, nous construisons un graphe évolutifG à partir de G en un temps polynomial et nous démontrons ensuite que G est le graphed’accessibilité de G, ce qui achève la démonstration.Soient un graphe statique non orienté G = (V,E) et un entier k. On construit un graphe évolutifG = (VG, EG) conformément à l’algorithme suivant :

– ∀i ∈ [1; |V |] ∩N+, créer vi dans VG– Pour toute arête (ui, uj) ∈ E, créer (vi, vj) et (vj, vi) dans EG avec comme séquences detemps de présence tij = i+ j

Montrons que G est isomorphe à AG, le graphe d’accessibilité de G. Pour ce faire, on démontrela proposition suivante : il existe un voyage entre vi et vj dans G si et seulement si (ui, uj) ∈ E.Supposons que (ui, uj) ∈ E, alors, par définition de G, il est évident qu’il existe un voyageentre vi et vj dans G. Supposons réciproquement que (ui, uj) n’appartienne pas à E et sup-posons i < j. Alors, il n’existe aucun voyage de vj à vi. En effet, étant donné un sommet vp,supposons qu’il existe un chemin de vj à vp et de vp à vi. Or, j + p > i + p donc ce cheminn’est pas réalisable. Il en suit que G est isomorphe à AG, le graphe d’accessibilité de G. Or,par le théorème 3.1, on peut trouver une clique maximale de AG, en cherchant une composantefortement connexe maximale de G. De plus, l’algorithme de construction de G à partir de G estde complexité O(|E|+ |V |). On a donc ramené P2 à P1 en un temps polynomial.

Théorème 3.2 (P1 est NP-complet).

Démonstration : P2 est un problème NP-complet 5. Or, nous avons démontré que P2 seramène à P1 en un temps polynomial. P1 est donc nécessairement NP-complet et nous endéduisons que trouver les composantes fortement connexes maximales de G est un problèmeNP-complet.

4 Arbre de recouvrementDans les sections 2 et 3, nous nous sommes successivement intéressés à la détermination du

plus court chemin entre deux sommets d’un graphe évolutif et à l’étude de la connexité d’untel graphe. Beaucoup de systèmes de communication (tels les LEO Satellites décrits dans lasection 5) disposent de ressources énergétiques limitées. Par conséquent, il est intéressant deminimiser l’énergie totale consommée par ces réseaux. Ce problème est appelé minimum energybroadcast routing (MEBR) dans un graphe : étant donné un nœud-source, il s’agit de trouverun sous-graphe du graphe initial, tel que l’énergie totale consommée soit minimisée.

En général, résoudre le problème MEBR revient à calculer un arbre de recouvrement mi-nimum (problème MST). Dans le cas statique, il existe des algorithmes résolvant le problèmede l’arbre de recouvrement minimum en un temps polynomial. Toutefois, dès que le grapheévolue dans le temps, ce problème devient automatiquement NP-difficile. Dans cette section,nous expliquons d’abord la relation entre les problèmes MEBR et MST. Ensuite, nous démon-trons d’abord que trouver un arbre de recouvrement est un problème NP-difficile. Enfin, nousdonnons un algorithme donnant un arbre de recouvrement minimum d’un graphe fortementconnexe, où le poids de chaque arête est le temps nécessaire pour la traverser.

5. Etant donné un graphe, trouver une clique maximale (au sens du nombre de sommets) du graphe faitpartie des problèmes NP-complets de KARP publiée en 1972.

10

4.1 Optimalité d’un arbre de recouvrement [4]Pour établir la relation entre les problèmes MEBR et MST, on énonce les deux théorèmes

suivants. Le premier théorème permet d’établir l’existence d’un arbre de recouvrement mini-mum :

Théorème 4.1. Soient un graphe évolutif G et un sommet r. S’il existe un voyage de r verschaque sommet de G, alors G contient un arbre de recouvrement.

Pour s’assurer que l’arbre de recouvrement minimum est effectivement la structure d’énergieminimale résolvant le problème MEBR, il faut que la fonction de coût respecte la propriétéd’inclusion suivante. (Le coût d’un graphe est défini comme la somme des coûts de toutes sesarêtes).

Théorème 4.2. Soient G un graphe évolutif, X un échantillon de sommets, r un nœud sourceet c, une fonction de coût. Si ∀ G ′′ ⊂ G ′ ⊆ G, on a c(G ′′) ≤ c(G ′), alors la structure résolvantle problème MEBR est un arbre évolutif et si X contient tous les sommets de G, c’est un arbreévolutif de recouvrement.

Si cette propriété d’inclusion de la fonction de coût est vérifiée, il est évident que l’arbrede recouvrement est la structure minimale recherchée. En effet, si on obtient un sous-graphequi n’est pas un arbre, il est toujours possible de réduire son coût en supprimant au moins unede ses arêtes. La propriété d’inclusion de la fonction de coût est vérifiée dans la plupart desapplications. Un cas où elle ne se vérifie pas est, par exemple, le cas d’un graphe dont les poidsdes arêtes peuvent être négatifs.

4.2 Trouver un arbre de recouvrement : un problème NP difficile [4]Il est facile de trouver un arbre de recouvrement d’un graphe évolutif. En effet, comme nous

le montrerons ultérieurement, il existe un algorithme fournissant, en un temps polynomial, unarbre de recouvrement minimum au sens temporel. Néanmoins, en général, déterminer un arbrede recouvrement minimum d’un graphe évolutif est un problème NP-difficile. Pour le démon-trer, nous ramenons le problème de l’arbre de Steiner à ce problème et nous utilisons le fait quel’arbre de Steiner est un problème NP-complet connu. Nous nous concentrons sur le cas où leparcours d’une arête nécessite un pas de temps.

Définissons le problème décisionnel P1 de la façon suivante : étant donné un graphe évolutifG = (VG, EG), une fonction donnant le coût de chaque arête, un sommet-racine r et un naturelk, existe-t-il un arbre de recouvrement de G de racine r et de poids inférieur ou égal à k ?Définissons également le problème P2 de la façon suivante : étant donné un graphe G = (V,E),une fonction donnant le coût de chaque arête, un ensemble de sommet X ⊆ V et un naturelk, existe-t-il un arbre de Steiner de poids inférieur ou égal à k contenant tous les sommets deX (c’est-à-dire un arbre contenant tous les sommets de X et éventuellement des sommets deV \X) ?

Lemme 4.1. P2 peut être ramené à P1 en un temps polynomial.

Démonstration Soit un graphe statique G = (V,E) (si le graphe est non-dirigé, on dé-double chaque arête pour en faire un graphe dirigé). Une fonction de coût c donne le coût dechaque arête. On extrait un ensemble de sommets X ⊆ V . Nous cherchons un arbre de Steinerminimum contenant l’ensemble des sommets de X. Construisons un graphe évolutif G de lafaçon suivante.

11

1. ∀y ∈ V \X, on crée deux sommets y′ et y′′. On définit Y ′ = {y′ : y ∈ Y }, Y ′′ = {y′′ : y ∈Y } et VG = V ∪ Y ′ ∪ Y ′′.

2. Pour tout couple y′, y′′ associé à un sommet y et pour tout x ∈ V , on crée trois arêtes(x, y′), (y′, y′′) et (y′′, y) de poids nul. On définit ainsi EG = E∪X×Y ′∪Y ′×Y ′′∪Y ′′×Y .

3. On définit des séquences de temps de présence pour chaque arête : chaque arête de Eest activée durant [2, |V | + 2], chaque arête de X × Y ′ est activée durant [0, 1], chaquearête de Y ′ × Y ′′ est activée durant [1, 2] et chaque arête de Y ′′ × Y est activée durant[|V |+ 1, |V |+ 2].

On a donc défini G = (VG, EG) dont la fonction de coût c′ est définie en ajoutant à c le poids(nul) des arêtes nouvellement créées. En supposant X non-vide, sélectionnons arbitrairementun noeud r ∈ X. Il existe un arbre de recouvrement de G, de source r et de poids inférieurou égal à k si et seulement s’il existe un arbre de Steiner dans G, de poids inférieur ou égalà k et contenant tous les sommets de X. En effet, supposons que l’on dispose d’un arbre derecouvrement de TG = (VG, ETG ), on construit alors un arbre statique T = (VT , ET ) avec VTobtenu en supprimant dans VTG les sommets de Y ′ et Y ′′ et ET obtenu en supprimant dansETG les arêtes dont une extrémité est dans Y ′ ou Y ′′. On démontre deux résultats :

– T est un arbre : Quel que soit le triplet y, y′, y′′, comme il n’existe qu’un chemin pouratteindre ces sommets à partir de r, cela implique que (r, y′), (y′, y′′) ∈ ETG . De plus, si(y′′, y) ∈ ETG tout autre arête d’extrémité y est superflue et n’appartient donc pas à ETG .Enfin, si (y′′, y) ∈ ETG alors il n’existe pas d’arête (y, v) pour v ∈ V . En effet, comme(y′′, y) est activée sur [|V |+ 1, |V |+ 2], une information diffusée à partir de r n’atteint yqu’au temps |V |+ 2 et ne peut donc pas être transmise à un autre sommet v ∈ V via y.

– T est de poids inférieur à k : comme les arêtes supprimées sont de poids zéro, T est ausside poids inférieur ou égal à k.

Supposons réciproquement que l’on dispose d’un arbre de Steiner de G, noté T = (VT , ET ),de poids inférieur ou égal à k et contenant tous les sommets de X. On construit un arbre derecouvrement de G de racine r de la façon suivante : TG = (VG, ETG ) tel que ETG contient toutesles arêtes de ET ainsi que les arêtes {(s, y′) : y′ ∈ Y ′} ∪ {(y′, y′′) : y ∈ Y } ∪ {(y′′, y) : y /∈ VT},ces arêtes étant définies sur les mêmes intervalles de temps que dans G. Le graphe TG est bienun arbre et il est bien de poids inférieur ou égal à k car les arêtes ajoutées sont de poids nul.

Théorème 4.3. Etant donné un graphe évolutif G = (VG, EG) et une fonction donnant le coûtde chaque arête, le problème qui consiste à trouver un arbre de recouvrement minimum de Gest un problème NP-difficile.

Démonstration : C’est une conséquence directe du lemme 4.1 en sachant que le problèmeP2 est NP-complet.

4.3 Algorithme de l’arbre de recouvrement minimum [1]Ici, nous donnons un algorithme permettant de trouver un arbre de recouvrement minimum

d’un graphe évolutif fortement connexe, dans le cas particulier où le poids est déterminé parle temps nécessaire pour transmettre une information à un sommet. Cet algorithme n’est doncpas généralisable au problème classique de l’arbre de recouvrement minimum, c’est-à-dire oùles coûts et le temps sont totalement indépendants. Toutefois, dans de nombreuses situations,le coût est directement proportionnel au temps, comme par exemple dans le cas des satellites

12

LEO dont nous parlerons dans la section 5. Il est alors intéressant de construire un arbre recou-vrant la totalité des sommets en un temps minimum. C’est ainsi que nous définissons l’arbrede recouvrement minimum dans l’algorithme 4.1. Le problème s’apparente donc au problèmedu plus court chemin traité dans la section 2, mais en ajoutant deux contraintes : le temps detraversée des arêtes n’est pas normalisé et le réseau obtenu doit être un arbre, contrairementau problème du plus court chemin.

Soit un graphe évolutif fortement connexe G = (VG, EG). On cherche N(= |VG|) arbres derecouvrement minimum de racine r pour chaque r ∈ VG. Les pas de temps sont normalisés etvalent tous 1. On suppose connue la séquence des temps de présence de toute arête : un tempsde présence i associé à une arête indique que l’arête est présente du temps i− 1 au temps i. Lepoids w(ui, uj) d’une arête (ui, uj) représente le temps nécessaire pour parcourir une arête etest supposé inférieur à 1, pour qu’une arête ne disparaisse pas pendant la transmission d’uneinformation. Pendant l’exécution de l’algorithme, f(r) contient un sous-ensemble des arêtesde l’arbre de recouvrement recherché et f(r) est mis-à-jour à chaque itération. Vf contientl’ensemble des sommets déjà introduits dans l’arbre. Enfin, chaque fois qu’un sommet v estvisité, on lui assigne une variable tv qui indique à quel moment il reçoit l’information venantde la racine r.

Algorithme 4.1.

1. Initialiser f(r)=∅, Vf = {r} et tr = 12. Tant que Vf 6= VG, faire :

(a) Définissons Γf comme l’ensemble des arêtes (ui, vi) telle que ui ∈ Vf et vi 6∈ Vf .Pour tout (ui, vi) ∈ Γf , choisir le plus petit temps fa(ui, vi) ≥ tui

+ w(ui, vi).(b) Choisir (uj, vj) tel que j = argmin

i(fa(ui, vi) + w(ui, vi))

(c) Affectation de tvj :i. si fa(uj, vj) = tuj

+ w(uj, vj), alors tvj= fa(uj, vj)

ii. sinon, si fa(uj, vj) − 1 est dans la séquence des temps de présence de (uj, vj),alors tvj

= tuj+ w(uj, vj)

iii. sinon, tvj= fa(uj, vj)− 1 + w(uj, vj)

(d) Ajouter vj à Vf et (uj, vj) à f(r)

Le point 2c est l’étape importante de l’algorithme. La première possibilité correspond aucas où l’information arrive au sommet vj exactement au temps fa(uj, vj). La seconde possibilitécorrespond au cas où l’arc est présent au temps fa(uj, vj) et au temps fa(uj, vj)− 1, alors celasignifie que fa(uj, vj) − 1 ≤ tuj

+ w(uj, vj) ≤ fa(uj, vj). Dès lors, l’information atteint vj autemps tuj

+ w(uj, vj). Dans les autres cas, l’information est transmise au cours de l’intervalle[fa(uj, vj)− 1,fa(uj, vj)] et parvient à vj au temps fa(uj, vj)− 1 + w(uj, vj).

Si D = maxv∈VG

d+(v), alors chaque pas de l’algorithme requiert O(NDlog(T )) opérations eton obtient donc une complexité de O(N2Dlog(T )). L’algorithme est relativement similaire àl’algorithme de Prim utilisé pour trouver un arbre de recouvrement d’un graphe statique : dela même manière, à chaque étape, on trouve une arête connectant un sommet déjà présentdans l’arbre de recouvrement à un sommet absent de l’arbre de recouvrement, en vérifiant quecette arête est accessible au pas de temps concerné. Toutefois, contrairement à l’algorithme dePrim, l’algorithme 4.1 fournit un arbre de recouvrement minimum, car le temps nécessaire à latraversée d’une arête est directement proportionnel au poids de l’arête et aussi car on s’est fixé

13

comme objectif de construire un arbre recouvrant l’ensemble des sommets le plus rapidementpossible.

Nous avons implémenté l’algorithme en utilisant le langage JAVA. Le code et la descriptionde chaque classe sont fournis en annexe (voir implémentation A.2). Le programme fonctionnecomme suit. Les sommets du graphe sont numérotés de 0 à N − 1. Les paramètres sont lenuméro du sommet racine et un tableau contenant, pour chaque sommet, la liste de ses voisinset la liste des pas de temps durant lesquels ils sont connectés. Le programme calcule lui-mêmela liste arrows contenant les arêtes du graphe évolutif [sous forme d’un tableau à trois entrées :sommet de départ, sommet d’arrivée et pas de temps durant lequel l’arête est active (si l’arêteest active durant plusieurs pas de temps, on la dédouble pour que chaque arête ne soit activeque durant un pas de temps)]. Le programme renvoie une liste des arêtes visitées et le pasde temps durant lequel chaque arête est parcourue de manière à constituer l’arbre de recou-vrement. L’implémentation a nécessité la définition de plusieurs classes (outre celle résolvantle problème) : des classes permettant la création et l’utilisation des listes chaînées, une classedéfinissant un sommet (on lui associe un label, la liste de tous ses voisins et les pas de tempsdurant lesquels ils sont connectés) et une classe définissant la liste chaînée arrows.

Ci-dessous, nous donnons un graphe (à gauche) ainsi que le résultat fourni par l’algorithme(à droite) en partant du noeud 1 comme racine. Un nombre décimal est associé à chaque arête :la partie entière de ce nombre représente le pas de temps durant lequel l’arête est active etla partie décimale représente le poids de l’arête. L’arbre obtenu est bien l’arbre recouvrantl’ensemble des sommets le plus tôt possible dans le temps.

1

2

3

4

2.1252.5

4.25

4.25

3.5

5.25

3.125

1

2

3

4

2.1252.5

3.125

14

5 ApplicationsNous présentons ici deux exemples d’applications : les LEO Satellites et les Interactions

Sociales.

5.1 LEO Satellites [6]Revenons au problème énoncé dans l’introduction et analysons le à la lumière de la théorie

vue dans les sections 1 à 4. Les satellites utilisés par les systèmes de communication à échellemondiale (téléphone, internet, etc.) sont caractérisés par l’orbite qu’ils décrivent autour de laTerre : on les subdivise en différentes catégories parmi lesquelles les satellites GEO (Geosta-tionary Earth Orbit) et LEO (Low Earth Orbit). Les satellites LEO décrivent une trajectoirerelativement proche de la surface de la Terre (de 500 à 2000 km d’altitude). Cette proximitéprésente deux avantages : l’énergie nécessaire pour interagir avec le satellite est réduite et letemps de transfert d’une information est très rapide (de l’ordre de 20 ms, contre 240 ms pour unsatellite GEO). Toutefois, cette basse altitude engendre également des difficultés de gestion duréseau : d’une part, le secteur couvert par un satellite est réduit, un grand nombre de satellitesest donc nécessaire, d’autre part, comme ces satellites ne sont pas géostationnaires, le sec-teur qu’ils survolent change constamment. Une étude topologique du réseau de communicationconsiste à déterminer, au départ d’un utilisateur émettant une information (par téléphone parexemple), la séquence de satellite optimale suivie par l’information pour atteindre n’importequel autre point du globe. Cela exige une analyse fine de la mobilité et des densité d’utilisateursdans le réseau.

– La mobilité du réseau est essentiellement due à la mobilité des satellites dont les positionsrelatives varient en fonction du temps (un satellite ne peut donc pas communiquer avecn’importe quel satellite, ni avec n’importe quel utilisateur à un instant donné). Mais cecaractère dynamique est aussi dû à la mobilité des utilisateurs (susceptibles de voyager).Comme les trajectoires des satellites sont connues, leur mobilité est quasi déterministe,alors que la mobilité des utilisateurs est indéterministe, mais nous la supposons négli-geable par rapport à celle des satellites. A cause de cette mobilité du réseau, lorsqu’uncanal de communication est ouvert entre deux utilisateurs, plusieurs transferts intercellu-laires (handover) peuvent avoir lieu. Lorsqu’un utilisateur n’est soudain plus couvert parun satellite ou lorsque celui-ci est surchargé, l’utilisateur doit instantanément être pris encharge par un autre satellite. Si le temps de transfert est trop long, cela peut occasionnerdes effets indésirables (coupures, communication brouillée...).

– La densité d’utilisateurs à la surface de la Terre n’est pas uniforme : certains secteurs dela planète présentent une demande très élevée en canaux de communication (les zones lesplus habitées) et doivent donc être desservies par plusieurs satellites en permanence.

Bref, l’ensemble du réseau forme un vaste graphe évolutif, dont les noeuds sont les satelliteset les utilisateurs (éventuellement regroupés). Le calcul de l’itinéraire suivi par une informationpartant d’un utilisateur et vers n’importe quel autre utilisateur passe par le calcul d’un arbrede recouvrement. Ce calcul peut être décomposé en deux étapes :

1. Le PRP (Probabilistic Routing Protocol) : on sait avec précision quand les satellitespeuvent entrer en communication (on connaît les temps durant lesquels chaque arêteest active). Par conséquent, à un instant donné, on peut calculer un arbre de recouvre-ment minimum suivant un critère choisi (par exemple minimiser le nombre de satellites

15

par lesquels l’information transite). On choisit ce critère pour que les itinéraires obtenusminimisent la probabilité d’un transfert intercellulaire.

2. Le HRP (Handover Rerouting Protocol) : si un transfert intercellulaire est nécessaire l’en-semble de l’arbre de recouvrement doit être recalculé en fonction des nouvelles donnéesdu problème.

En pratique, le graphe évolue en permanence, car des utilisateurs entrent et sortent et aussicar les satellites sont en mouvement. Il faut donc continuellement mettre à jour l’arbre de recou-vrement minimum permettant aux utilisateurs d’un secteur de communiquer avec l’ensembledes utilisateurs de la planète. Suivant le critère choisi, le calcul de cet arbre de recouvrementpeut être un problème facile à résoudre (par exemple avec l’algorithme proposé dans la section4.1 ou un problème NP-difficile.

5.2 Les interactions sociales [5]Lorsqu’un groupe d’individus interagit, il est possible de définir un ensemble de données.

Cet ensemble peut être caractérisé au moyen d’un graphe évolutif. En fait, nous mettons enévidence le fait que différents individus interagissent d’une quelconque manière. Par exemple,nous pouvons imaginer une interaction de type bluetooth : les individus peuvent être en dé-placement ; toutefois, ils peuvent effectuer des échanges avec d’autres, lorsqu’un interlocuteurpotentiel est suffisamment proche. Ainsi, les individus sont représentés par des sommets mobileset les interactions entre eux sont mises en évidence par des arêtes d’activité correspondant à ladurée de leur dialogue.

On peut élargir cette analyse primaire à trois cas :– interaction à proximité, simultanée et régulière,– interaction à proximité, simultanée et temporaire,– interaction asynchrone

On constate que les deux premiers cas nécessitent une synchronisation des interactions quidoivent se dérouler lorsque les interlocuteurs sont suffisamment proches. Le dernier cas estasynchrone, ce qui permet aux individus d’interagir à grande distance, de manière différée.Nous illustrons ces trois cas respectivement via les réseaux Reality Mining (noté MN), Infocom(noté IF) et Facebook (noté FB).

En 2004, de juin à décembre, le MIT a souhaité analyser les interactions entre ses différentsintervenants, professeurs, assistants et étudiants. L’analyse issue de MN s’est effectuée au moyendu bluetooth activé sur les téléphones mobiles selon des intervalles réguliers de 5 minutes. Lasituation est représentée par un graphe évolutif, dont les sommets pondérés, par rapport aunombre d’interactions, sont les téléphones et les arêtes expriment le fait que les téléphones sontconnectés via bluetooth. Cette situation est typique des interactions quotidiennes qu’un indi-vidu a régulièrement dans son environnement de travail. On constate qu’en début de semaineacadémique, les étudiants interagissent beaucoup avec les assistants et professeurs tandis quele week-end, ils demeurent davantage entre eux. Si on modélisait la situation au moyen d’ungraphe statique, on n’observerait pas de fluctuation flagrante au cours d’une même semaine, nid’apparition ou disparition d’arête. Sur un semestre, les fluctuations d’une semaine à l’autresont faibles ; on observe davantage les variations du nombre d’interactions lors d’évènementstels que les congés.

Durant l’année 2006, une conférence (IF) rassemblant 78 personnes a fait l’objet de pareilleanalyse. Celle-ci approxime les interactions qui ont lieu lors d’une réunion, ce qui diffère du

16

type d’interactions qu’on rencontre quotidiennement. Nous formulons la situation sous formede graphe évolutif, dont les sommets sont les personnes, reliés par une arête s’ils dialoguententre eux. On constate que les individus n’interagissent pas beaucoup lors de l’inscription, maisbien lors du repas.

FB est un célèbre réseau social qui permet à ses membres d’interagir de manière simultanéeou différée, et ce à travers le monde. L’ensemble des interactions de 100000 utilisateurs localisésà Santa Barbara (CA) a été analysé. Ce genre d’interactions implique un grand nombre denoeuds et a priori d’arêtes. On remarque dans cette situation que les propriétés de la structuredu graphe fluctuent beaucoup sur une semaine.

17

ConclusionTout au long de ce rapport, nous avons exploré le concept de graphe évolutif. Cette étude

a été motivée par l’existence de nombreuses situations dynamiques que nous rencontrons auquotidien. En particulier, nous nous sommes concentrés sur le transport de l’information aucours du temps, parmi des ensembles d’objets pouvant être mobiles.

Nous avons donc débuté par la présentation des notions propres aux graphes évolutifs. Cetteprésentation a défini les rudiments, où la définition de graphe évolutif est établie : il s’agit desous-graphes définis sur des intervalles de temps. Nous avons introduit la notion de voyage ausein d’un graphe évolutif. Cette notion concerne les possibilités de chemins au cours du tempsdans le graphe. Le concept d’arbre a été transposé dans le cas dynamique, d’une manière rela-tivement proche de celle d’un arbre de recouvrement du cas statique.

Ensuite, nous avons étudié l’optimisation des voyages au sens du plus court chemin. Uneparticularité de cette optimisation dans le cas temporel est la possibilité d’optimiser selon dif-férents critères. Les hypothèses de travail ont été énoncées, en insistant sur la conservation del’information au cours du temps. Cela nous a permis d’élaborer trois algorithmes (2.1, 2.2 et2.3) qui respectivement traitent Intervalle de présence unitaire, Parcourir plusieurs arêtes enun pas de temps et Parcourir une arête en plusieurs pas de temps.

Par après, on a défini la connexité-temporel. On a d’ailleurs constaté l’existence de deuxtypes de composantes fortement connexes : une analogue au cas statique et une autre qualifiéed’ouverte. Nous avons poursuivi par l’énoncé et la preuve d’une proposition affirmant l’exis-tence d’un algorithme polynomial déterminant si un graphe évolutif est fortement connexe ounon. Nous avons également démontré que le problème d’identifier les composantes fortementconnexes dans le cas temporel était un problème NP-complet.

Nous avons poursuivi avec le concept d’arbre de recouvrement, permettant de diffuser l’in-formation d’un sommet source à un maximum de sommets du graphe évolutif. Ce type destructure graphique peut être optimisée de telle sorte qu’on minimise son coût. On a vu quecela était analogue au fait de minimiser l’énergie d’un système de communication. Il s’agit del’arbre de recouvrement minimum dont on a prouvé que l’identification consiste en un problèmeNP-difficile.

Enfin, nous avons terminé par la description de deux applications modélisables au moyende la notion des graphes évolutifs. Les LEO Satellites qui supportent les communications, eninteragissant à une faible altitude entre eux et les systèmes mobiles ou fixes situés au sol. Parailleurs, nous avons constaté que les graphes statiques ne permettaient pas de mettre en valeurle caractère évolutif de différents types d’interactions sociales.

En annexes, vous trouverez l’ensemble des implémentations exécutant les algorithmes ren-seignés. Aussi, nos références bibliographiques y sont mentionnées.

I

Annexes

II

A Implémentations

A.1 Le plus court cheminShortestPath.java

import java.lang.Number;import java.lang.reflect.Array;/∗∗∗ Shortest Path resout le probleme du plus court chemin (premier voyage) dans un graphe

evolutif∗ (pour des couts normalises et des vitesses normalises comme defini dans la section 2).∗/public class ShortestPath{

private static final int infinity = Integer.MAX_VALUE;

/∗∗∗ @pre: adj est une matrice tridimensionnelle donnant pour chaque sommet la liste∗ de ces voisins et a quel insant ils sont connectes, k est le numero du sommet a partir∗ duquel on veut calculer les plus court chemin.∗ @post: renvoie l arbre de plus court chemin sous forme d une liste contenant chaque

sommet,∗ le pas de temps ou il recoit l information et le sommet qui lui transmet l information.∗/public static NodeStackVertex resolution(int[][][] adj,int k) throws

EmptyStackException{int n = Array.getLength(adj);int[] d =new int[n];

//initialisation des distancesfor(int i=0;i<n;i++){

d[i]=infinity;}d[k]=0;

//Q est defini comme dans la description de l algorithme (voir section 2 du rapport)NodeStackVertex Q = new NodeStackVertex();Q.push(new Vertex(infinity,infinity));Vertex x = new Vertex(k,0);

//Tree est l arbre de plus court chemin (rempli iterativement)NodeStackVertex Tree = new NodeStackVertex();Tree.push(new Vertex(infinity,infinity,infinity));Tree.push(new Vertex(k,0,infinity));

int i=0;

while(x.getTime()!=infinity){

III

while(i==x.getTime()){int time = x.getTime();int name = x.getName();

/∗∗∗ La premiere boucle ci−dessous (j) parcourt l ensemble des voisins de x.∗/for (int j=0;j<Array.getLength(adj[name]);j++){

int[] v = adj[name][j];boolean found = false;int qsdfghjklm=v[0];int fv=d[v[0]];

/∗∗∗ La seconde boucle parcourt les pas de temps durant lesquels x et v

sont∗ connectes.∗/for(int l=1;l<Array.getLength(v) && !found;l++){

if(v[l]>=i+1){found=true;fv=v[l];

}}

/∗∗∗ Mise−a−jour (si necessaire) de la distance d(v) et de la liste Q∗/if(found && d[v[0]] > fv){

d[v[0]]=fv;Q.insert(new Vertex(v[0],fv));Tree.insert(new Vertex(v[0],fv,x.getName()));//

OOOOOOOOOOOOOOOOO}

}x=Q.pop();

}i++;

}return Tree;

}}

IV

Vertex.java

public class Vertex{private int name;private int time;private int voisin;

/∗∗∗ Constructeur classique (n itialise pas voisin)∗/public Vertex(int givenName,int givenTime){

name=givenName;time=givenTime;

}

/∗∗∗ Constructeur classique∗/public Vertex(int givenName,int givenTime,int givenVoisin){

name=givenName;time=givenTime;voisin=givenVoisin;

}

public int getName(){return name;

}

public int getTime(){return time;

}

public int getVoisin(){return voisin;

}}

V

NodeStackVertex.java

import java.lang.Number;

/∗∗∗ La classe NodeStackVertex implemente une pile de Vertex∗/

public class NodeStackVertex {protected NodeVertex top; // reference to the head NodeVertexprotected int size; // number of elements in the stackprivate static final int INFINITY=Integer.MAX_VALUE;/∗∗∗ @pre: −∗ @post: construit une pile vide∗/public NodeStackVertex() {

top = null;size = 0;

}

/∗∗∗ @pre:−∗ @post: renvoie la taille de la pile courante.∗/public int size() {

return size;}

/∗∗∗ @pre: −∗ @post: renvoie true si la pile est vide, false sinon.∗/public boolean isEmpty() {

if (top == null)return true;

return false;}

/∗∗∗ @pre: elem est un Vertex∗ @post: elem est introduit au sommet de la pile∗/public void push(Vertex elem) {

NodeVertex v = new NodeVertex (elem, top); // create and link− in a newNodeVertex

top = v;size++;

VI

}

/∗∗∗ @pre: v est un Vertex et les sommets de la pile courante son∗ classes par ordre croissant du temps ou ils recoivent l information∗ de la racine∗ @post: Si v n etait pas dans la pile courante, v est insere dans la∗ pile en respectant son ordre. Si un Vertex de meme numero que v est∗ deja dans la pile mais a un temps superieur, il adopte automatiquement∗ le temps donne par v∗/public void insert(Vertex v){

if(this.size()==1){this.push(v);

}else{

NodeVertex x=top;NodeVertex y=x;Vertex topVertex=x.getElement();if(topVertex.getTime()>=v.getTime()){

this.push(v);}else if(topVertex.getName()!=v.getName()){

while(topVertex.getTime()<v.getTime()){y=x;x=x.getNext();topVertex=x.getElement();

}y.setNext(new NodeVertex (v,x));y=y.getNext();

}while(topVertex.getTime()<INFINITY){

if(topVertex.getName()==v.getName()){y.setNext(x.getNext());

}y=x;x=x.getNext();topVertex=x.getElement();

}}

}

/∗∗∗ @pre: la pile n est pas vide∗ @post: le premier Vertex de la pile est renvoye∗/public Vertex top() throws EmptyStackException {

if (isEmpty())throw new EmptyStackException("Stack is empty.");

return top.getElement();

VII

}

/∗∗∗ @pre: La pile n est pas vide∗ @post: Le premier Vertex de la pile est renvoye et supprimer de la pile.∗/public Vertex pop() throws EmptyStackException {

if (isEmpty())throw new EmptyStackException("Stack is empty.");

Vertex temp = top.getElement();top = top.getNext(); // link−out the former topsize−−;return temp;

}}

NodeVertex.java

/∗∗∗ Classe implementant les noeuds utilises par∗ NodeStackVertex. L element de chaque noeud est un∗ tableau de Vertex.∗/public class NodeVertex {

// Instance variables:private Vertex element;private NodeVertex next;

/∗∗ Cree un noeud de reference nulle∗/public NodeVertex() {

this(null, null);}

/∗∗ Cree un noeud de sommet e et de voisin n ∗/public NodeVertex(Vertex e, NodeVertex n) {

element = e;next = n;

}

public Vertex getElement() {return element;

}

public NodeVertex getNext() {return next;

}

public void setElement(Vertex newElem) {

VIII

element = newElem;}

public void setNext(NodeVertex newNext) {next = newNext;

}}

EmptyStackException.java

public class EmptyStackException extends Exception {

public EmptyStackException(String string) {System.out.println(string);

}

}

IX

A.2 L’arbre de recouvrement minimumSpanningTreeExtended.java

import java.lang.Number;import java.lang.reflect.Array;import java.util.Arrays;/∗∗∗ Cette classe permet de trouver un arbre de recouvrement d un graphe evolutif∗ fortement connexe. Le poids de chaque arete est la temps necessaire a la∗ traversee de l arete.∗/public class SpanningTreeExtended{

private static final int infinity=Integer.MAX_VALUE;private NodeStackArrow arrows;private int n;private Adjacency[] adj;

/∗∗∗ Constructeur classique∗/public SpanningTreeExtended(Adjacency[] adj,NodeStackArrow arrows){

this.adj=adj;n=Array.getLength(adj);this.arrows=arrows;

}

/∗∗∗ constructeur creant la liste arrows sur simple base du tableau∗ tridimensionnel A.∗/public SpanningTreeExtended(Adjacency[] adj){

this.adj=adj;n=Array.getLength(adj);arrows=new NodeStackArrow();for (int i=0;i<Array.getLength(adj);i++){

int vertex = adj[i].getVertex();int[][] schedule=adj[i].getSchedule();for (int j=0;j<Array.getLength(schedule);j++){

if(schedule[j][0]!=infinity){for (int k=0;k<Array.getLength(schedule[j]);k++){

int[] newArrow=new int[3];newArrow[0]=vertex;newArrow[1]=j;newArrow[2]=schedule[j][k];arrows.insert(newArrow);

}}

}

X

}}

/∗∗∗ @pre: r est un entier representant un sommet.∗ @post:renvoie un tableau contenant toutes les aretes necessaires∗ pour construire l arbre de recouvrement minimum.∗/public int[][] resolution(int r) throws EmptyStackException{

// Permet d extraire les poids de toutes les aretesdouble[][] weights=Adjacency.weights(adj);

//tableau ou les aretes de l arbre de recouvrement sont stockees au fur//et a mesureint[][] f = new int[n−1][3];

//tableau des pas de temps ou l information envoyee par le sommet racine//arrive a chaque sommetdouble[] t= new double[n];t[r]=1;

//found[v] est true si v est deja dans l arbre de recouvrementboolean[] found = new boolean[n];Arrays.fill(found,false);found[r]=true;

for(int nfound=1; nfound<n;nfound++){//permet de trouver l arete suivante la moins chereint[] result=arrows.nextArrow(found,t,weights);int uj=result[0];int vj=result[1];int fa=result[2];double weight=weights[uj][vj];

if (fa==t[uj]+weight){t[vj]=fa;

}else {

//renvoie true si fa(uj,vj)−1 est dans la sequence des temps de presence de (uj,vj)

boolean falast=adj[uj].isLastTime(vj,fa);if(falast){

t[vj]=t[uj]+weight;}else{

t[vj]=fa−1+weight;}

}

XI

found[vj]=true;f[nfound−1][0]=uj;f[nfound−1][1]=vj;f[nfound−1][2]=fa;

}return f;

}}

Adjacency.java

import java.lang.Number;import java.lang.reflect.Array;import java.util.Arrays;/∗∗∗ Adjacency est associe a un vecteur. weight represente le poids de l ensemble∗ des arete dont ce sommet fait partie. Schedule represente les sequences de∗ temps de presence de chaque arete.∗/public class Adjacency{

private double[] weight;private int[][] schedule;private int vertex;

/∗∗∗ Constructeur Classique∗/public Adjacency(int vertex,double[] weight, int[][] schedule){

this.vertex=vertex;this.weight=weight;this.schedule=schedule;

}

/∗∗∗ @pre: v est un sommet, t un temps∗ @post: renvoie true si le sommet courant et v sont connectes au temps t−1∗/public boolean isLastTime(int v,int t){

int[] times=schedule[v];//cette boucle parcourt la liste des pas de temps durant lesquels//le sommet courant est connecte a v.for (int i=1;i<Array.getLength(times) && times[i]<=t;i++){

if(times[i]==t){if (times[i−1]==t−1){

return true;}else{

XII

return false;}

}}return false;

}

public double[] getWeight(){return weight;

}

public int getVertex(){return vertex;

}

public int[][] getSchedule(){return schedule;

}

/∗∗∗ @pre: adj est un tableau de sommets representes sous la forme d objets "Adjacency"∗ @post: renvoie le un tableau contenant les poids de chaque arete apparaissant dans∗ les composantes de adj.∗/public static double[][] weights(Adjacency[] adj){

int n=Array.getLength(adj);double[][] result = new double[n][n];for(int i=1; i<n;i++){

result[i]=adj[i].getWeight();}return result;

}}

XIII

NodeStackArrow.java

import java.lang.Number;/∗∗∗ La classe NodeStackArrow implemente une pile contenant les aretes∗ du graphe evolutif (sous forme d un tableau d entiers a trois entrees: sommet de∗ depart, sommet d arrivee et pas de temps durant lequel l arete est∗ active (si l arete est active est active durant plusieurs pas de temps,∗ on la dedouble pour que chaque arete ne soit active que durant un pas de∗ temps).∗/public class NodeStackArrow {

protected NodeArrow top;protected int size;/∗∗∗ @pre: −∗ @post: construit une pile vide∗/public NodeStackArrow(){

top = null;size = 0;

}

/∗∗∗ @pre:−∗ @post: renvoie la taille de la pile courante.∗/public int size() {

return size;}

/∗∗∗ @pre: −∗ @post: renvoie true si la pile est vide, false sinon.∗/public boolean isEmpty() {

if (top == null)return true;

return false;}

/∗∗∗ @pre: elem est une arete (tableau a trois composantes)∗ @post: elem est introduit au sommet de la pile∗/public void push(int[] elem) {

NodeArrow v = new NodeArrow(elem, top);top = v;size++;

XIV

}

/∗∗∗ @pre: la pile n est pas vide∗ @post: la premiere arete de la pile est renvoye∗/public int[] top() throws EmptyStackException {

if (isEmpty())throw new EmptyStackException("Stack is empty.");

return top.getElement();}

/∗∗∗ @pre: La pile n est pas vide∗ @post: La premiere arete de la pile est renvoye et supprimee de la pile.∗/public int[] pop() throws EmptyStackException {

if (isEmpty())throw new EmptyStackException("Stack is empty.");

int[] temp = top.getElement();top = top.getNext(); // link−out the former top NodeArrowsize−−;return temp;

}

/∗∗∗ @pre: found contient des valeurs true ou false associee a chaque arete si∗ found[a] est true, a a deja ete visite dans l execution du programme, si∗ found[a] est false, a n a pas encore ete visite dans l execution du programme.∗ t contient les temps ou chaque arete sommet est visite (si un sommet v∗ n a pas encore ete visite, t[v]=infinity. weights contient les poids de chaque arete∗ @post: un tableau est renvoyee, donnant l arete suivante a visiter pour completer∗ l arbre de recouvrement minimum (sommets incidents et temps au cours duquel l

arete∗ est traversee. (Voir description de l algorithme dans le rapport).∗/public int[] nextArrow(boolean[] found, double[] t,double[][] weights) throws

EmptyStackException{

if (isEmpty()){throw new EmptyStackException("Stack is empty.");}

int[] result=new int[3];NodeArrow x=top;int[] xi=x.getElement();double weight=weights[xi[0]][xi[1]];Integer time=new Integer(xi[2]);

if(found[xi[0]] && !found[xi[1]] && time.doubleValue()>=t[xi[0]]+weight){result[0]=xi[0];result[1]=xi[1];

XV

result[2]=xi[2];int a=result[0];int b=result[1];int c=result[2];int d=1;

}else{

NodeArrow y=x;x=x.getNext();while(x!=null){

xi=x.getElement();time=new Integer(xi[2]);weight=weights[xi[0]][xi[1]];if(found[xi[0]] && !found[xi[1]] && time.doubleValue()>=t[xi[0]]+weight

){result[0]=xi[0];result[1]=xi[1];result[2]=xi[2];y.setNext(x.getNext());break;

}y=y.getNext();x=x.getNext();

}}return result;

}

/∗∗∗ @pre: arrow est une arete et les aretes de la pile courante son classes par∗ ordre croissant du temps ou elles sont actives∗ @post: Si arrow n etait pas dans la pile courante, arrow est insere dans la pile∗ en respectant son ordre. Si une arete de meme emetteur et destinateur que arrow∗ est deja dans la pile mais a un temps superieur, il adopte automatiquement le∗ temps donne par v et sa position dans la pile est changee en fonction de ce nouveau

temps.∗/public void insert(int[] arrow){

if(this.size()==0){this.push(arrow);

}else{

NodeArrow x=top;NodeArrow y=x;int[] topTable=x.getElement();if(topTable[2]>=arrow[2]){

this.push(arrow);}else{

XVI

while(topTable[2]<arrow[2] && x.getNext()!=null){y=x;x=x.getNext();topTable=x.getElement();

}y.setNext(new NodeArrow(arrow,x));

}}size++;

}}

NodeArrow.java

/∗∗∗ Classe implementant les noeuds utilises par∗ NodeArrowStack. L element de chaque noeud est un∗ tableau reel representant une arete (sommet∗ origine, sommet destinataire et pas de temps∗ durant lequel l arete est active).∗/public class NodeArrow {

private int[] element;private NodeArrow next;

/∗∗ Noeud d element et de voisin nuls ∗/public NodeArrow() {

this(null, null);}

/∗∗ Cree un noeud d element e et de voisin n∗/public NodeArrow(int[] e, NodeArrow n) {

element = e;next = n;

}

public int[] getElement() {return element;

}

public NodeArrow getNext() {return next;

}

public void setElement(int[] newElem) {element = newElem;

}

XVII

public void setNext(NodeArrow newNext) {next = newNext;

}}

EmptyStackException.java

public class EmptyStackException extends Exception {

public EmptyStackException(String string) {System.out.println(string);

}

}

XVIII

Bibliographie

[1] S. Bhadra and A. Ferreira. Computing multicast trees in dynamic networks using evolving graphs. INRIA,2002.

[2] A. Ferreira. On models and algorithms for dynamic communication networks : the case for evolving graphs,proceeding of 4e rencontres francophones sur les apects algorithmiques des télécommunications, 155-161.2002.

[3] A. Ferreira. Building a reference combinatorial model for dynamic networks : initial results in elvolvinggraphs. INRIA, 2003.

[4] A. Ferreira and A. Jarry. Complexity of minimum spanning tree in evolving graphs and the minimum-energybroadcast routing problem, in proceedings of wiopt’04, modeling and optimization in mobile, ad-hoc andwireless networks. 2004.

[5] V. Nicosia, J. Tang, M. Musolesi, G. Russo, and C. Mascolo. Components in time varying graphs. AmericanInstitute of Physics, 2012.

[6] I. Stojmenovic. Handbook of wireless networks and mobile computing. WILEY-INTERSCIENCE, 2002.

XIX