Structures de données IFT-2000 Abder Alikacem Les graphes Semaine 5, suite et fin… Édition Septembre 2009 Département d’informatique et de génie logiciel

Deuxième partie 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

Défilement d’un graphe Rappel Deux manières standard d'exécuter cette opération: Parcours par contagion ou par largeur Breadth-First Search ou BFS Parcours par sondage ou en profondeur(Depth-First Search ou DFS) Question: Est-ce que tout graphe peut être parcouru par ces 2 algorithmes ?

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. consulter un sommet 6. voir si un chemin existe entre 2 sommets 7. trouver le chemin le plus court (# arêtes/arcs, distance) 8. 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 template <typename T> class Graphe { public: /** Constructeurs (graphe vide)*/ Graphe(); 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é

Implantation dans une matrice d’adjacence 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 Linéariser la matrice 3 Cas d’un graphe non orienté ( i + 1 ) * i / 2 + j 1 1 1 1 1 1

STL : Standard Template Library Conteneurs: En C++, une classe contenant un ensemble d’éléments d'un certain type est appelée conteneur. Ce sont donc eux qui contiendront les informations que l’on veut stocker. Itérateurs: utilisés pour parcourir les items qui se retrouvent dans les conteneurs, ils jouent un peu le rôle de pointeurs sur des éléments d’un conteneur. Algorithmes: utilisés pour faire des traitements sur les éléments qui se retrouvent dans les conteneurs. http://www.sgi.com/tech/stl/

STL : Standard Template Library Conteneurs Séquentiels vector: tableau dynamique - extensible - accès direct en O(1) - insertions et retraits à la fin en O(1) - insertions et retraits lents au milieu list: liste doublement chaînée - insertions et retraits n’importe où en O(1) - accès au début et à la fin en O(1) - accès lent aux autres éléments http://www.sgi.com/tech/stl/

Liste (list) et vecteur (vector) Méthodes communes à vector et list push_back(): Ajoute à la fin du conteneur. pop_back(): Enlève le dernier objet du conteneur back(): Retourne l'objet situé à la fin du conteneur front(): Retourne l'objet situé au début du conteneur Pour les conteneurs de type list seulement push_front(): Ajoute au début du conteneur pop_front(): Enlève le premier objet du conteneur Pour les conteneurs de type vector seulement operator[] : Retourne l'objet situé à la position i du conteneur at (): Comme le précédent mais déclenche une exception out of range lorsqu'un indice est incorrect. resize(): Redéfini la taille du conteneur capacity(): Retourne la capacité du conteneur reserve(): Redéfini la capacité du conteneur

Les itérateurs Les principaux opérateurs sont * donnant accès à la valeur, ++ et -- pour incrémenter et décrémenter une valeur. Opérateur * : Retourne l’élément de la position courante Opérateur ++ : Fait pointer l’itérateur à l’élément suivant Opérateur == : Indique si 2 itérateurs pointent sur le même élément Opérateur = : Assigne un itérateur #include <list> #include <iostream> using namespace std; int main( ) { list <int> list1; for (int i = 1; i<=40; i++) list1.push_back(i+i); list <int> :: iterator i; //reverse_iterator //const_iterator for (i = list1.begin( ); i!=list1.end( ); i++) cout <<*i << “ “ ; return 0 ; }

Pile (stack) et file (file) L’adapteur de conteneurs Stack ( la pile ) Peut être implémentée avec vector, list, (*)deque Principe LIFO : push et pop à la même extrémité Queue ( la file ) Dérive d’un (*)deque. Principe FIFO (*)deque: tableau dynamique qui peut s’étendre par les deux extrémités. C’est un des conteneurs séquentiels de la STL http://www.sgi.com/tech/stl/

Pile (stack) Lib « stack » stack est générique Déclaration (pile d’entiers) Empiler Dépiler Taille de la pile Pile vide? Sommet de la pile #include <stack> using namespace std; stack<int> s; s.push(1); s.pop(); int n = s.size(); if(s.empty()){…} int i = s.top();

File (queue) Lib « queue » queue est générique Déclaration Taille Ajouter en tête Supprimer en queue Tête de la file Fin de la file #include <queue> using namespace std; queue<int > f; int n =f.size(); f.push(10); f.pop(); int tete =f.front(); int fin = f.back();

Retour à la 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 2 3 Classe Graphe Laboratoire#5 Implantation dans une liste de sommets adjacents template <typename T> class Graphe { public: //.. private: class Noeud { public: T data; /* au lieu de T data, on peut avoir T* ou int */ Noeud * suivant; /* chaînage des sommets adjacents */ }; /* le noeud typique du graphe */ 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 4 Cas d’un graphe non orienté template <typename T> class Graphe { public: //.. private: class AreteNode { public: int sommet[2]; AreteNode * lien[2]; }; typedef AreteNode * AretePtr; class Noeud T data; AretePtr first; vector<Noeud> listeSommets; } B Solution: liste des arêtes

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

Plan Tri topologique Retour sur la connexité des graphes Algorithme de Dijkstra Algorithme de Bellman-Ford Algorithme A*

Tri topologique : exemple 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!

Tri topologique : exemple 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 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 et : s1 < s2

Tri topologique : trace de l’algorithme B A D G F E C G A E B D F C (a) (b)

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 si le graphe G n'est pas connexe, il apparaîtra comme un ensemble de sous-graphes connexes. Chacun de ces sous-graphes forme une composante connexe maximale

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. Un graphe orienté G est faiblement connexe ssi son graphe non orienté sous-jacent G’ 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 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) L’algorithme est basée sur la technique de relâchement Exemple. Plus court chemin entre s et  i Î v (v : l’ensemble des sommets) 3 8 s d c b a 3 5 1 s d c b a 3 5 1 3 4 9

Algorithme de Dijkstra 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.

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é ? V :ensemble des sommets d’un graphe S : sommets dont les poids finaux de plus court chemin à partir de la source ont été calculés. T: file pour gérer les sommets de v – S suivant leur attribut yi .

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

Algorithme de Dijkstra   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 - - - - - -

Algorithme de Dijkstra   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 - - - - - -

Algorithme de Dijkstra  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 - - -

Algorithme de Dijkstra 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 -

Algorithme de Dijkstra 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 -

Algorithme de Dijkstra 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

Algorithme de Dijkstra 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

Algorithme de Dijkstra 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

Algorithme de Dijkstra Autre exemple 9,a 6 3,s a b 6 a b 3 3 2 2 s 1 1 s 1 12 12 1 c c 11,b

Pause, profitons pour nous amuser!   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…   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 

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  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 

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 Limité à des poids positifs Poids positifs et négatifs

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. 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 a 3 3 s 6 -3 s 3 -6 5 5 c c

Algorithme de Bellman-Ford 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. 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é ?

Algorithme de Bellman-Ford 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)

Algorithme de Bellman-Ford 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)

Algorithme de Bellman-Ford 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)

Algorithme de Bellman-Ford 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

Algorithme de Bellman-Ford 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)

Algorithme de Bellman-Ford 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!

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) 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. Conséquence l’algorithme A* est plus performant que n’importe quel autre algorithme puisqu’il diminue l’ensemble des sommets à explorer. 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.

Algorithme A* Théorème de Pythagore H 2 = (Coté oppose) 2 + S 40 (Coté adjacent) 2 H 2 = 40 2 + 20 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

Retour sur les piles Pile, modèle hybride p1 pile nœud... en-tête (header) tab p1 suiv cpt 11 cpt 4 4 3 debut pile

Graphe, lab#6 /** * Algorithme de Warshall */ template <typename T> Graphe<T> fermetureGraphe(Graphe<T> g); Graphe (int nbSommet); Graphe (const Graphe&); Graphe(const Graphe& g, std::vector<T>&); ~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); bool arcExiste ( T s1, T s2); int nbSommets(); void affiche(); std::vector<T> listerSommetsGraphe(); int ordreEntreeSommet(T sommet); std::vector<T> listerSommetsAdjacents(T sommet); int ordreSortieSommet(T sommet) ; Algorithme de Warshall {Soit A, un graphe orienté} P  A Pour k = 1, 2, ..., n Pour i = 1, 2, ..., n Pour j = 1, 2, ..., n Pij  Pij ou (Pik et Pkj)

Graphe, lab#6 Algorithme de Warshall {Soit A, un graphe orienté} P  A Pour k = 1, 2, ..., n Pour i = 1, 2, ..., n Pour j = 1, 2, ..., n Pij  Pij ou (Pik et Pkj) Graphe, lab#6 template <typename T> Graphe_Lab7::Graphe<T> fermetureGraphe (Graphe_Lab7::Graphe<T> g) { Graphe<T> fermG(g); vector<T> v = fermG.listerSommetsGraphe(); int nb = fermG.nbSommets(); for (int k = 0; k < nb; k++) for (int i = 0; i < nb; i++) for (int j = 0; j < nb; j++) if (fermG.arcExiste(v[i], v[j]) == false) if ((fermG.arcExiste(v[i], v[k]) == true) && (fermG.arcExiste(v[k], v[j]) == true)) fermG.ajouterArc(v[i], v[j]); } return fermG;