Structures de données IFT-2000 Abder Alikacem Les graphes (3) Semaine 7 É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*

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

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

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

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.

Algorithme de Dijkstra et le chemin Pour aller d’un sommet A à un sommet B appliquer l’algorithme de Dijkstra tout 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 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 Exercice 6 a b 3 2 s 1 1 12 c Appliquez l’algorithme de Dijkstra à ce graphe à partir du sommet s

Algorithme de Dijkstra Réponse 9,a 3,s 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…   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. a 3 s 6 -3 5 c

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

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

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!

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 est encore inconnu. 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. On utilise généralement deux heuristiques, la distance euclidienne et la distance de Manhattan

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

Graphe, lab#7 /** * Algorithme de Warshall */ template <typename T> Graphe<T> fermetureGraphe(Graphe<T> g)throw(logic_error); 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#7 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#7 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;