Chapitre VIII. Introduction aux graphes Définitions Structures de données Connexité Arbre couvrant de poids minimal Parcours des graphes orientés

Définitions Graphes orientés Un graphe orienté : - ensemble des sommets - ensemble des arcs : relation binaire sur N Exemple : 1 2 3 4 N=?, A=?

Arcs et sommets - l’extrémité initiale (début) - l’extrémité terminale (fin) est un prédécesseur de est un successeur de

Etiquettes Etiquettes Le nom d’un sommet doit être unique dans un graphe Plusieurs sommets peuvent avoir la même étiquette Est fille de 1 2 Anne Claude

Chemins Un chemin dans un graphe orienté est une liste La longueur d’un chemin est k-1 = nbr arcs faisant partie du chemin Le cas trivial k=1: tout sommet n isolé est un chemin de longueur zéro de n à n

Graphes cycliques et acycliques Un cycle dans un graphe orienté est un chemin de longueur 1 ou plus qui part et aboutit au même sommet Un chemin trivial (l=0) n’est pas un cycle Une chemin composé d’un seul arc est un cycle de longueur 1 Si un graphe a un ou plusieurs Cycles on l’appelle « graphe cyclique » Sinon « acyclique » 1 2 3 4

Problème Dans un graphe orienté- itinéraire représenté sous forme d’une liste simplement chainée supprimer tous les cycles

Graphes non-orientés Une arête est un ensemble de deux sommets L’arête indique que les sommets sont liés dans deux directions Les sommets sont dits adjacents Un graphe ayant des arêtes, c’est –à-dire possédant une relation symétrique des arcs est appelé un graphe non-orienté

Structures de données (1) Listes d’adjacence Type Liste =^maillon Maillon=Enregistrement IdNoeud : Nœud {entier- pour simplifier} Suivant: Liste Fin Nœuds : tableau[1…N] de Liste

Exemple 5 7 1 2 1 3 2 4 5 6 4 6 3 7 Graphe orienté 8 7

Matrice d’adjacence arcs : tableau[1..N][1..N] de Booléen

Représentation d’un graphe non-orienté 5 7 1 2 1 Transformer le GO en GNO! 3 2 4 5 6 4 6 3 7 8 7 Principe : remplacer chaque arête par les arcs allant dans deux directions, matrice d’adjacence est symétrique

Connexité(1) Composante connexe : ensemble de sommets pour lesquels il existe un chemin entre tout sommet et n’importe quel autre sommet Une composante connexe est maximale : aucun sommet faisant partie d’une composante connexe ne possède un chemin vers un sommet en dehors de la composante connexe Si un graphe consiste en une seule composante connexe, alors on l’appelle graphe connexe

Connexité(2) Connexité est une relation d’équivalence définie sur les sommets du graphe non-orienté P: niPnj ssi il existe un chemin de ni vers nj 1) Réflexive : nPn pour tout sommet n puisqu’il existe un chemin de longueur 0 entre tout sommet et lui-même 2) Symétrique : si niPnj alors il existe un chemin de ni vers nj. Puisque le graphe est non-orienté, la séquence inverse de sommets est aussi un chemin. Donc njPni 3) Transitive : si niPnj et njPnk alors niPnj.

Algorithme pour construire les composantes connexes(1) Principe : - Commencer par le graphe G0 composé des sommets de G avec aucune arête. - Considérer les arêtes de G une par une pour construire une séquence des graphes G0, G1, G, … où Gi est composé des sommets de G et des i premières arêtes de G

Algorithme pour construire les composantes connexes(2) La base : la liste des arêtes non-utilisées est vide Initialisation. G0 est seulement composé des sommets de G sans arêtes. Chaque sommet est une composante connexe. La récurrence. On suppose qu’on a les composantes connexes du graphe Gi après avoir considéré les i premières arêtes. Considérons i+1 ère arête (ni, nj) 1. Si ni et nj font partie de la même composante de Gi , alors Gi+1 a le même ensemble des composantes connexes. 2. Si ni et nj font partie de composantes différentes, on fusionne les composantes contenant ni et nj afin d’obtenir les composantes connexes pour Gi+1 Lorsqu’on a considéré toutes les arêtes de cette manière, on obtient les composantes connexes du graphe G

Construction des composantes connexes (2) Problèmes à résoudre : (1) Etant donné un sommet, trouver sa composante courante (2) Fusionner deux composantes en une seule Choix de structures de données : chaque composante connexe d’un graphe sera représentée par un arbre. Le résultat de l’algorithme : une forêt des arbres

Construction des composantes connexes(3) 2 3 1 1 2 4 5 6 6 3 7 7 4 8 8 Deux polygones sont considérés adjacents ssi ils ont une arête commune 5

Construction des composantes connexes(4) 2 6 O 1 2 3 4 5 6 7 8 1 3 J 2 4 BC 5 6 6 Ve R 4 6 Vi 1 5 4 B 8 Ro 7

Construction des composantes connexes(5) Liste des arêtes N°arête N1 N2 1 2 3 6 4 5 5 7 8 6 4 1 2

Structures de données(1) -Liste d’adjacence -Liste des arêtes. -Liste des nœuds d’un arbre Type ListeArêtes = ^Arête Arête = Enregistrement noeud1, noeud2 : TypeNoeud Suivant : ListeArêtes FinEnregistrement Arêtes : ListeArêtes Tout sommet du graphe doit posséder un nœud d’arbre correspondant TypeNœud peut être une étiquette de nœud (entier)

Structures de données(2) Type PtrNoeudArbre = ^NoeudArbre NoeudArbre = Enregistrement père : PtrNoeudArbre hauteur: entier Fin Enregistrement Nœuds: Tableau[1..n] de PtrNoeud Ce tableau associe un nœud dans un arbre général à chaque sommet du graphe

Fonctions auxiliaires (1)Fonction TrouveRacine( a: nœud): PtrNoeudArbre { renvoie la racine de l’arbre contenant le nœud x correspondant au sommet courant du graphe} Var Racine, Courant : PtrNoeudArbre; Début Racine : = nœuds[a]; TQ Racine.père<>NIL faire Racine:=Racine^.père; FTQ Retourner Racine FinTrouveRacine

Fonctions Auxiliaires (2) (2)Procédure FusionArbres(x,y,: PtrNoeudArbre) {fusionne les arbres dont les racines sont x et y, en faisant devenir racine du plus bas le descendant de la racine du plus haut} Var pbas, phaut : PtrNoeudArbre Début Si x^.hauteur>y^.hauteur alors phaut:=x pbas=:=y sinon phaut:= y pbas:=x FSi pbas^.père:= phaut; Si pbas^.hauteur = pahaut^.hauteur phaut^.hauteur:=phaut^.hauteur+1 FSI FinFusionArbres

Algorithme de construction des composantes connexes Soient G – le graphe contenant n sommets, e: sa liste des arêtes « arêtes » 1) Initialiser n arbres 2)Pour toutes les arêtes dans la liste : Si les extrémités sont dans deux arbres différents, fusionner les composantes-arbres.

Algorithme de construction des composantes connexes(2) Procédure CompCon(réf Noeuds : Tableau [1..n]de PtrNoeuds; arêtes : ListeArêtes) Var u:TypeNoeud a,b: PtrNoeudArbre e:ListeArêtes Pour u de 1 à n faire new(Noeuds[u]) Nœuds[u].père:=NIL Nœuds[u].hauteur:=0; FPour e:=arêtes TQ e<>NIL faire a:=TrouveRacine(e^.noeud1) b:=TrouveRacine(e^.noeud2) Si a<>b alors FusionArbres(a,b); FSi E:=e^.suivant FTQ FinCompCon

Analyse Après l’exécution le tableau « Nœuds » code les arbres-composantes-connexes. Temps d’exécution (1) FusionArbre : le chemin de n’importe quel nœud d’un arbre construit par la procédure FusionArbre : le temps est inférieur à log(n). Alors TrouveRacine prend un temps en O(log(n)) (2) Procédure FusionArbres : O(1) (2)Initialisation (boucle Pour) O(n) (3)Boucle while : O(mlog(n)), m – nombre des arêtes O(n+mlog(n)) En général donc O(n+mlog(n)) –cas spécifiques - absence des arêtes O(n) - fortement connexe O(mlog(n))

Arbre couvrant de poids minimal Soit W={wi,j} l’ensemble des « poids » des arêtes du graphe G. Nous allons nous limiter aux graphes connexes Un arbre couvrant (non-ordonné, sans racine = un graphe non-orienté n’ayant pas de cycles) Un arbre couvrant pour un graphe non-orienté G est composé des sommets de G avec un sous-ensemble des arêtes de G qui relient les sommets : il existe un chemin entre tous les sommets, pris deux par deux, en prenant uniquement les arêtes de l’arbre couvrant forment un arbre sans racine, non-ordonné Un arbre couvrant de poids minimal: la somme des poids des arêtes est la plus petite que possible

Algorithme de Kruskal 1. Considérer les arêtes dans l’ordre croisant de leurs poids 2. Considérant les arêtes, Si une arête possède ses deux extrémités dans des composantes différentes, alors on sélectionne cette arête pour l’arbre couvrant et on fusionne les composantes de la même façon que dans l’algorithme de construction des composantes connexes. sinon on ne sélectionne pas l’arête pour l’arbre couvrant.

Parcours des graphes orientés(1) Recherche en profondeur (dfs) Principe : similaire au parcours en profondeur des arbres. Pb : existence des cycles ( possibilité de boucler à l’infini!) Solution : marquer les sommets visités Structures de données : Graphe : tableau de sommets avec des listes d’adjacence

Parcours des graphes orientés(2) Type Liste =^maillon Maillon=Enregistrement IdNoeud : Nœud {entier} Marque: (visité, non-visité) Suivant: Liste Fin Graphe : tableau[1…N] de Liste

Parcours des graphes orientés(3) Parcours en profondeur Procédure dfs(G: Graphe; u: entier){numéro du nœud ) Var p:Liste {liste d’adjacence du nœud u} V: entier {sommet dans la cellule sur lequel pointe p} Début G[u].Marque:=Visité p:=G[u].suivant TQ p<>NIL faire v:=p^.IdNoeud Si G[v].Marque:=Non-visité alors dfs(v) FSi p:=p^.suivant FTQ Findfs Le temps d’exécution est proportionnel au nombre des arcs explorés. Version itérative :utilisation d’une pile de parcours

Parcours des graphes orientés(4) Parcours en largeur : visiter d’abord tous les voisins du sommet courant qui n’ont pas été marqués Procédure bfs( G : graphe, u:entier) Var v,w,i: entiers F: file Début F:=file-vide; G[u].Marque:=Visité Enfiler(F,u) TQ non est-vide(F) faire v: = premier(F); Defiler(F); p:=G[v].suivant TQ p<>NIL faire w:=p^.IdNoeud Si G[w].Marque:=Non-visité alors G[w].Marque=Visité Enfiler(F,w) FSi FTQ Finbfs