Structures de données IFT-2000

Structures de données IFT-2000
Abder Alikacem Les graphes (2) Semaine 6 Édition Septembre 2009 Département d’informatique et de génie logiciel

Plan Parcours d’un graphe par contagion (ou largeur)
Parcours d’un graphe par sondage (ou profondeur) Description d’un graphe en terme de type abstrait Implantation 4 2 5 3 1

Spécifications de l’interface du type Graphe
Description en termes de types abstraits 1. ajouter un sommet à un graphe 2. ajouter un arc/arête à un graphe 3. ôter un sommet du graphe et tous les arcs/arêtes associés 4. ôter un arc/arête 5. permettre l'accès à un sommet nommé (désigné) 6. indiquer si un sommet n'a pas de voisins 7. parcourir les voisins d'un sommet 8. voir si un chemin existe entre 2 sommets trouver le chemin le plus court (# arêtes/arcs, distance) 10. trouver tous les chemins entre 2 sommets Etc..

Implantation Il existe deux principales méthodes de modélisation des graphes en tant que type abstrait: les matrices et les listes dites de connectivité ou d'adjacence. Le choix entre elles se fera en fonction de la densité du graphe. Par densité, on entend la proportion d'arcs effectifs par rapport au nombre maximum d'arcs ou d’arêtes possibles: NbArcs / NbSommets2 dans le cas de graphe orienté. NbAretes / (NbSommets(NbSommets-1)/2) dans le cas d’un graphe non orienté

Interface class Arc { public: int u; int v; Arc(int i, int j) { u = i;
v = v; } }; Interface template <typename T> class Graphe { public: Graphe(); Graphe(vector<T> &sommets, vector<Arc> &arcs); Graphe (const Graphe&); ~Graphe (); Graphe& operator = (const Graphe&); void ajouterSommet(T s); void ajouterArc (T s1, T S2); void enleverArc (T s1, T s2); void enleverSommet ( T s); bool sommetExiste(T s) const; int nbSommets() const; // etc... private: //… class Sommet { public: …getData(); void setData(..); //etc.. private: … data; int no; int tag; bool pres; };

Implantation dans une matrice d’adjacence
Classe Graphe Implantation dans une matrice d’adjacence template <typename T> class Graphe { public: //.. private: int nbSommets; T* sommets; int **mat; //implémentation dans une matrice } // de sommets adjacents 1 2 5 4 3 Cas d’un graphe orienté

Classe Graphe Implantation dans une matrice d’adjacence template <typename T> class Graphe { public: //.. private: int nbSommets; T* sommets; int **mat; // trop de perte mémoire!! } 1 2 5 4 3 Cas d’un graphe non orienté Linéariser la matrice

Classe Graphe 1 1 1 1 1 1 2 1 3 1 1 1 1 Implantation dans une matrice d’adjacence 4 1 1 template <typename T> class Graphe { public: //.. private: int nbSommets; T* sommets; int *mat; // tableau à une dimension } 1 2 5 4 3 Cas d’un graphe non orienté ( i + 1 ) * i / 2 + j 1 1 1 1 1 1

Classe Graphe Implantation dans une matrice d’adjacence template <typename T> class Graphe { public: //.. private: vector<T> sommets; // Les sommets vector< vector<int> > voisins; // Les sommets adjacents } Utilisation de vector de la STL

Implantation dans une liste de sommets adjacents
1 Classe Graphe Implantation dans une liste de sommets adjacents template <typename T> class Graphe { public: //.. private: class Noeud { public: T data; Noeud * suivant; }; int nbSommet; /* nombre de sommets dans le graphe */ int nbSommetMax; /* nombre total possible de sommets */ T * sommet; /* tableau représentant les sommets*/ Noeud** listeSommet; /* les listes de sommets adjacents*/ } 1 1 3 2 2 1 3 2

Implantation dans une liste de sommets adjacents
Classe Graphe Implantation dans une liste de sommets adjacents template <typename T> class Graphe { public: //.. private: class Noeud { public: T data; //données // dans un sommet list<int> voisins; }; vector<Noeud> listeSommets; } Utilisation de vector et list de la STL

Classe Graphe Implantation dans une liste de sommets adjacents
Cas d’un graphe non orienté La liste des sommets adjacents soufre de la même redondance que nous avons rencontrer avec les matrices de sommets adjacents.

Cas d’un graphe non orienté
Classe Graphe Cas d’un graphe non orienté template <typename T> class Graphe { public: //.. private: class AreteNode { public: int sommet[3]; AreteNode * lien[3]; }; typedef AreteNode * AretePtr; class Noeud T data; AretePtr first; vector<Noeud> listeSommets; } Liste des arêtes

Structures de données IFT-2000
Abder Alikacem Les graphes (3) Édition Septembre 2009 Département d’informatique et de génie logiciel

Plan Tri topologique Connexité des graphes Algorithme de Dijkstra
Algorithme de Bellman-Ford Algorithme A*

Tri topologique : exemple
Au début de certains livres, les auteurs indiquent les dépendances chronologiques entre les chapitres en les représentant par un diagramme. Par exemple, pour lire le chapitre 16, il faut avoir lu les chapitres 4, 8 et 15. Etc.. Un lecteur courageux veut lire le strict minimum pour appréhender le chapitre 21. Il faut donc qu'il transforme les dépendances du diagramme en un ordre partiel déterminant la liste des chapitres nécessaires au chapitre 21. Bien sûr, ceci n'est pas possible si le graphe de dépendance contient un cycle. L'opération qui consiste à mettre ainsi en ordre les sommets d'un graphe orienté sans circuit est appelée le tri topologique

Examen Hiver 2003 On cherche à déterminer dans quel ordre on enfiler ses vêtements pour s'habiller de la tête aux pieds. Sachant que : Il faut d’abord enfiler son caleçon pour mettre ensuite ses chaussures, son pantalon et sa ceinture. Pour mettre ses chaussures il faut avoir mis ses chaussettes et son pantalon. Pour mettre sa ceinture il faut avoir enfile sa chemise. Pour mettre sa veste il faut avoir enfilé sa cravate et sa ceinture. Pour mettre sa cravate il faut avoir mis sa chemise. On peut mettre sa montre n'importe quand!

Examen Hiver 2003 slip chaussettes pantalon chaussures chemise cravate
veste ceinture montre Graphe de dépendance Graphe trié topologiquement ch ettes slip pant. montre se ce cr ve res

Tri topologique Idée : ordonner les sommets selon la préséance indiquée par les arcs ordre linéaire partiel sur les sommets But : comparer deux sommets s1 et s2 pour savoir si l’un vient avant l’autre Précondition S est un graphe orienté et acyclique Postcondition s1 vient avant s2  il y a un chemin de s1 à s2, alors : s1 < s2

Tri topologique : trace de l’algorithme

Retour sur la connexité des graphes
Un graphe non orienté G est connexe ssi il existe un chemin entre n’importe quelle paire de sommets distincts du graphe Un sommet isolé (de degré 0) constitue toujours une composante connexe à lui seul.

Connexité des graphes non orientés
Que se passe-t-il si le graphe G n'est pas connexe? G apparaîtra comme un ensemble de sous-graphes connexes. On appelle chacun de ces sous-graphes une composante connexe de G: G'=(S',A') une composante connexe de G G' est un sous-graphe connexe maximal :  S'' = S'  {v} tel que G'' = (S'', A') est une composante connexe

Connexité des graphes orientés
Un graphe G est fortement connexe ssi pour n’importe quelle paire de sommets distincts (a,b) de G, il existe un chemin du sommet a au sommet b et un autre chemin du sommet b au sommet a.

Connexité des graphes orientés
Un graphe orienté G est faiblement connexe ssi son graphe non orienté sous-jacent G’ est connexe. Autrement dit, le graphe G’, qui est le graphe G dans lequel les arcs ont été remplacés par des arêtes, est connexe.

Problématique des plus courts chemins
Comment trouver le plus court chemin entre 2 sommets s et t d'un graphe G? Plus cours chemin pour tout couple de sommets (coûteux dans notre cas) Algorithmes de Floyd-Warshall. Les plus courts chemins à origine unique Parcours exhaustif des nœuds Algorithme de parcours par largeur (BFS) (graphes non pondérés) Algorithme de Dijkstra (pondération positive). Algorithme de Bellman-Ford (pondération négative).

Algorithme de Dijkstra
Se base sur le principe de la sous-optimalité Si p est le plus court chemin entre deux sommets i et j alors:  k, un sommet appartenant à p le sous-chemin de p (i, k) est optimal (le plus court) le sous-chemin de p (k, j) est optimal (le plus court) Exemple. Plus court chemin entre s et  i Î v (v : l’ensemble des sommets) s d c b a 3 5 1 8 4 9 s d c b a 3 5 1 3

L’algorithme est basée sur la technique de relâchement C’est une méthode qui diminue progressivement le poids du plus cours chemin pour chaque sommet jusqu’à ce qu’il soit égal au poids du plus court chemin. Pour chaque sommet i  v , on maintient à jour un attribut yi : une estimation de la pondération d’un plus court chemin: État initial : ys = 0 (s étant la source) yi = + avec i  s À chaque étape : essayer de minimiser les yi État final : yi = lpcc(s,i) (lpcc: le plus court chemin)

RELÂCHER (a,b, c (a,b)) Si yb > ya + c (a,b) Alors yb  ya + c (a,b) 5 9 5 6 2 2 a b a b Relâcher(a,b, c(a,b)) Relâcher(a,b, c(a,b)) 5 7 5 6 2 2 a b a b Dans l’algorithme de Dijkstra, chaque arc est relâché exactement une fois.

Soit V est l’ensemble des sommets d’un graphes L’algorithme maintient à jour un ensemble S contenant les sommets dont les poids finaux de plus court chemin à partir de la source ont été calculés. À chaque itération, l’algorithme choisit le sommet j  v – S dont l’estimation de plus court chemin est minimale, l’insère dans S et relâche tous les arcs partant de j. L’algorithme gère une file T pour y emmagasiner les sommets de v – S suivant leur attribut yi . L’Algorithme de Dijkstra…

Soit V l’ensemble des sommets d’un graphes Initialiser yi = + pour tous les sommets i Initialiser ys = 0. Initialiser S à l'ensemble vide, T = V. Tant que T n'est pas vide 1.Sélectionner le sommet j de T de plus petite valeur yi 2.Faire T = T \ j et S = S  j 3.Pour tous les sommets k de T adjacents à j, faire RELÂCHER(j, k, c(j,k)) Fin Tant que. Complexité ?

Algorithme de Dijkstra et le chemin
Pour aller d’un sommet A à un sommet B appliquer l’algorithme de Dijkstra avec le sommet A comme source, en conservant pour chaque nœud le nœud origine à partir duquel sa plus petite distance de la source a été calculée. d d RELÂCHER (a,b, c (a,b)) Si yb > ya + c (a,b) Alors yb  ya + c (a,b) P[b]  a Tous les P[i] sont initialisés à NIL au départ (i  v ) e e h f g

  b d 5 4 6 a f  1 8 2 3 2 10 c e   V, S, T a b c d e f V: ensemble des sommets S: les sommets solutionnés T: une file d’attente (suivant le coût) Y: tableau des coûts P: tableau des sommets précédents Y      P - - - - - -

  b d 5 4 6 a f  1 8 2 3 2 10 c e   V, S, T a b c d e f Y      P - - - - - -

 b d 5 4 6 a f  1 8 2 3 2 10 c e 2 (a)  V, S, T a c b d e f Y 2 4    P - a a - - -

3 (c) 10 (c) b d 5 4 6 a f  1 8 2 3 2 10 c e 2 (a) 12 (c) V, S, T a c b d e f Y 2 3 10 12  P - a c c c -

3 (c) 8 (b) b d 5 4 6 a f  1 8 2 3 2 10 c e 2 (a) 12 (c) V, S, T a c b d e f Y 2 3 8 12  P - a c b c -

3 (c) 8 (b) b d 5 4 6 a f 14 (d) 1 8 2 3 2 10 c e 2 (a) 10 (d) V, S, T a c b d e f Y 2 3 8 10 14 P - a c b d d

3 (c) 8 (b) b d 5 4 6 a f 13 (e) 1 8 2 3 2 10 c e 2 (a) 10 (d) V, S, T a c b d e f Y 2 3 8 10 13 P - a c b d e

3 (c) 8 (b) b d 5 4 6 a 13 (e) f 1 8 2 3 2 10 c e 2 (a) 10 (d) V, S, T a c b d e f Y 2 3 8 10 13 P - a c b d e

Exercice 6 a b 3 2 s 1 1 12 c Appliquez l’algorithme de Dijkstra à ce graphe à partir du sommet s

Réponse 9,a 3,b 6 a b 3 2 s 1 12 1 c 11,b

Amusons nous!   6 a b 3 2 s 1 12 1 c  Appliquons le principe du relâchement à chaque arc de ce graphe, l’ordre des arcs est choisi aléatoirement. Un arc relâché sera mis avec une autre couleur.

1er tour…   6 a b 3 2 s 1 12 1 c 

1er tour… 3  6 a b 3 2 s 1 12 1 c 

1er tour… 3  6 a b 3 2 s 1 12 1 c  On a relâché tous les arcs. Recommençons une nouvelle fois. Un arc relâché sera mis cette fois en bleu

2ième tour… 3  6 a b 3 2 s 1 12 1 c 

2ième tour… 3 9 6 a b 3 2 s 1 12 1 c 

2ième tour… 3 9 6 a b 3 2 s 1 12 1 c 11

Un autre tour? 3 9 6 a b 3 2 s 1 12 1 c 11 On arrête ce jeu!

Un autre tour? 3 9 6 9 3 a b 6 3 a b 3 2 s 1 2 s 1 12 1 12 1 c c 11 11 Résultat à l’issu de l’exécution de l’algorithme de notre jeu … Il s’agit en fait de la simulation De l’algorithme de Bellman-Ford! Résultat suite à l’exécution de l’algorithme de Dijkstra

Problème : Limité à des poids positifs  pas de cycle négatif Solution : Bellman-Ford d d e e h f g

Algorithme de Bellman-Ford
Problématique des arcs de poids négatifs Si un graphe ne contient aucun circuit de poids négatif accessible à partir d’une origine s, alors, pour tout sommet i  v, le poids du plus court chemin reste bien défini, même si sa valeur est négative. a 3 s 6 -3 5 c

Problématique des arcs de poids négatifs S’il existe un circuit de poids négatif accessible depuis s, le poids du plus court chemin n’est pas correctement défini. Aucun chemin entre s et un sommet du circuit ne peut être plus court, on peut toujours trouver un encore plus court! a 3 s 3 -6 5 c

Stratégie Faire les étapes nécessaires pour faire converger le poids des chemins sachant qu’un plus court chemin de s à tout autre sommet est un chemin d’ordre au plus n -1 arcs. Vérifier s’ils ont tous convergé. Retourner VRAI si c’est le cas. Retourner FAUX sinon. Utilisation de la technique du relâchement Comme dans Dijkstra, l’Algorithme utilise le relâchement pour diminuer progressivement une estimation yv du poids d’un plus court chemin depuis l’origine. À la différence de Dijkstra, chaque arc est relâché plusieurs fois. L’algorithme de Bellman-Ford…

Soit le graphe G(V,E) Initialiser yi = + pour tous les sommets i Initialiser ys = 0. Répéter |V| - 1 FOIS Pour tout arc (u,v) de E faire RELÂCHER(u, v, c(u,v)) Pour tout arc (u,v) de E faire Si yv > yu + c(u,v) Alors Retourner FAUX Retourner VRAI Complexité ?

Exemple 1 s d c b a 3 5 1 -3  s d c b a 3 5 1 -3 6 4 9 Étape 1 relaxation de tous les arcs dans l’ordre : (s,a) (s,c) (a,b) (a,c) (b,d) (c,a) (c,b) (c,d) (d,b) (d,s)

s d c b a 3 5 1 -3 6 4 9 s d c b a 3 5 1 -3 4 7 Étape 2 relaxation de tous les arcs dans l’ordre : (s,a) (s,c) (a,b) (a,c) (b,d) (c,a) (c,b) (c,d) (d,b) (d,s)

s d c b a 3 5 1 -3 4 7 s d c b a 3 5 1 -3 2 4 Étape 3 relaxation de tous les arcs dans l’ordre : (s,a) (s,c) (a,b) (a,c) (b,d) (c,a) (c,b) (c,d) (d,b) (d,s)

s d c b a 3 5 1 -3 2 4 s d c b a 3 5 1 -3 4 Étape 4 relaxation de tous les arcs dans l’ordre : (s,a) (s,c) (a,b) (a,c) (b,d) (c,a) (c,b) (c,d) (d,b) (d,s) Cycle de coût négatif: réduction encore possible !

Bellman-Ford revu…. Soit le graphe G(V,E)
Initialiser yi = + pour tous les sommets i Initialiser ys = 0. K  1 Répéter Stable  VRAI Pour tout arc (u,v) de E faire RELÂCHER(u, v, c(u,v)) Si …Alors Stable  FAUX K  k + 1 Tant que Stable est FAUX ET k < n+1 Si non Stable alors présence d’un circuit de poids négatif

Exemple 2 s d c b a 3 5 -3 1 -1  s d c b a 3 5 -3 1 -1 8 4 7 Étape 1 relaxation de tous les arcs dans l’ordre : (s,a) (s,c) (a,b) (a,c) (b,d) (c,a) (c,b) (c,d) (d,b) (d,s)

s d c b a 3 5 -3 1 -1 8 4 7 s d c b a 3 5 -3 1 -1 8 4 7 Étape 2 relaxation de tous les arcs dans l’ordre : (s,a) (s,c) (a,b) (a,c) (b,d) (c,a) (c,b) (c,d) (d,b) (d,s) Pas de réduction possible : coûts corrects!

Recherche de chemins de coût minimal avec l’algorithme A*
Jeux vidéo Animation des personnages non joueurs Déplacement réaliste d’un personnage contrôlé par le joueur vers un objectif désigné par le joueur Simulation – vie artificielle Etude du comportement d’une foule, du trafic automobile, … Effets spéciaux (scènes de bataille, …)

Algorithme A* Principe général : évaluation du coût total d’un sommet
Coût total (F) = Coût depuis la source(G) + Coût vers la destination(H) G : Coût depuis la source Algorithmes classiques (Ford, Bellman, Dijkstra) H : Coût vers la destination Difficile puisque le reste du chemin (vers la destination) est encore inconnu.

Algorithme A* Pourquoi évaluer un coût vers la destination ?
Afin de resserrer l’ensemble des sommets à explorer en privilégiant les sommets « qui semblent » nous rapprocher de la destination. Remarque Dans le cas d’un algorithme de recherche plus classique (Dijsktra), on effectue une recherche exhaustive parmi TOUS les sommets candidats. Conséquence l’algorithme A* est plus performant que n’importe quel autre algorithme puisqu’il diminue l’ensemble des sommets à explorer.

Algorithme A* Comment évaluer un coût vers la destination ?
En utilisant des heuristiques (prédictions) afin d’évaluer un coût vers la destination INFERIEUR au coût réel (encore inconnu). À ce titre, A* est un algorithme dit optimiste. Remarque Si l’heuristique était supérieur au coût réel, on risquerait de générer un chemin qui ne soit pas minimal.

Algorithme A* Théorème de Pythagore H 2 = (Coté oppose) 2 + S 40
(Coté adjacent) 2 H 2 = = 2000 H = 20 x (5) 1/2 S 40 H 20 D Distance euclidienne

Algorithme A* S Nombre de cellules, en horizontal et en vertical entre la source et la destination. Plus conforme à la nature des déplacements autorisés (haut, bas, gauche, droite) D Distance de Manhattan

Structures de données IFT-2000

Présentations similaires

Présentation au sujet: "Structures de données IFT-2000"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back

Entrer

S'autoriser via un réseau social:

Structures de données IFT-2000

Présentations similaires

Présentation au sujet: "Structures de données IFT-2000"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back