151 lines
4.3 KiB
Markdown
151 lines
4.3 KiB
Markdown
TP Graphes 3 : Parcours et Coloration
|
|
============
|
|
|
|
Le TP est prévu pour être fait en utilisant le codage des graphes à l'aide de matrices d'adjacence.
|
|
Pour plus de clarté, vous pouvez utiliser un nouveau fichier, en copiant les structures et fonctions nécessaires depuis les TPs précédants.
|
|
|
|
- - - - -
|
|
Exercice 1 : Parcours en largeur
|
|
----------
|
|
|
|
Pour cet exercice, vous aurez besoin de file FIFO, dont voici la structure et les primitives :
|
|
```
|
|
struct file{
|
|
int data;
|
|
struct file* succ;
|
|
};
|
|
|
|
typedef struct file fifo;
|
|
|
|
void enqueue(fifo **fi,int v){
|
|
fifo *nf=malloc(sizeof(fifo));
|
|
nf->data=v;
|
|
nf->succ=*fi;
|
|
(*fi)=nf;
|
|
}
|
|
|
|
int dequeue(fifo **fi){
|
|
fifo *lect=*fi;
|
|
if(lect->succ==NULL){
|
|
int res=lect->data;
|
|
*fi=NULL;
|
|
return res;
|
|
}
|
|
while(lect->succ->succ!=NULL){
|
|
lect=lect->succ;
|
|
}
|
|
int res=lect->succ->data;
|
|
fifo *temp=lect->succ;
|
|
lect->succ=NULL;
|
|
free(temp);
|
|
return res;
|
|
}
|
|
int empty(fifo *fi){
|
|
return fi==NULL;
|
|
}
|
|
```
|
|
On rappelle que pour une variable `fifo *fi`, on empile 3 en faisant `enqueue(&fi,3)` et on défile (et on stocke dans une variable x) en faisant `x=dequeue(&fi)`.
|
|
|
|
**Question :**
|
|
|
|
Ecrire une fonction qui, étant donnés un graphe g et un sommet v de ce graphe, renvoie sous forme de file FIFO l'ensemble des voisins de v dans g :
|
|
```
|
|
fifo* fileVoisins(graphe g,int v);
|
|
```
|
|
|
|
|
|
**Question :**
|
|
|
|
Ecrire une fonction effectuant le parcours en largeur d'un graphe g à partir d'un sommet v.
|
|
On pourra se contenter d'afficher sur la sortie standard la numérotation ainsi que les distances obtenues, plutôt que de les renvoyer :
|
|
```
|
|
void parcoursLargeur(graphe g,int v);
|
|
```
|
|
|
|
**Question :**
|
|
|
|
Tester sur un graphe (au hasard celui des frontières). Cela correspond-t-il à une exécution manuelle de l'algorithme ?
|
|
|
|
|
|
- - - - -
|
|
Exercice 2 : Parcours en profondeur
|
|
----------
|
|
|
|
Pour implémenter le parcours en profondeur d'un graphe, nous aurons besoin d'une pile, dont voici la structure et les primitives :
|
|
```
|
|
struct pile{
|
|
int head;
|
|
struct pile* suite;
|
|
};
|
|
|
|
typedef struct pile pile;
|
|
|
|
|
|
int emptyPile(pile *p){
|
|
return p==NULL;
|
|
}
|
|
|
|
void push(pile **p,int v){
|
|
pile* newpile=malloc(sizeof(pile));
|
|
|
|
newpile->head=v;
|
|
newpile->suite=*p;
|
|
*p=newpile;
|
|
}
|
|
|
|
int pop(pile **p){
|
|
int resultat=(*p)->head;
|
|
pile* temp=*p;
|
|
*p=(*p)->suite;
|
|
free(temp);
|
|
return resultat;
|
|
}
|
|
|
|
int first(pile *p){
|
|
return p->head;
|
|
}
|
|
```
|
|
On rappelle que pour une variable `pile *fi`, on push 3 en faisant `push(&fi,3)` et on dépile (et on stocke dans une variable x) en faisant `x=pop(&fi)`.
|
|
La primitive `x=first(fi)` permet de récupérer le sommet de la pile sans dépiler.
|
|
|
|
**Question :**
|
|
|
|
Ecrire une fonction effectuant le parcours en profondeur d'un graphe g à partir d'un sommet v.
|
|
On pourra se contenter d'afficher sur la sortie standard la numérotation de premier passage plutôt que de les renvoyer :
|
|
```
|
|
void parcoursProfondeur(graphe g,int v);
|
|
```
|
|
|
|
**Question :**
|
|
|
|
Tester sur un graphe (au hasard celui des frontières). Cela correspond-t-il à une exécution manuelle de l'algorithme ?
|
|
|
|
**Question :**
|
|
|
|
Adaptez votre code pour également calculer, puis afficher, la numérotation de dernier passage.
|
|
|
|
- - - - -
|
|
Exercice 3 : Algorithme de Welsh-Powell
|
|
----------
|
|
|
|
On va implémenter l'algorithme de Welsh-Powell de coloriage glouton des graphes.
|
|
Les premières questions visent à donner des fonctions aidant à l'implémentation de l'algorithme. A vous de les suivre ou non.
|
|
|
|
**Question : Liste des sommets selon leur degré**
|
|
|
|
-Créer une fonction `int* tableauDegre(graphe g);` renvoyant un tableau où la case i contient le degré du sommet i.
|
|
|
|
-Créer une fonction `int indiceMax(int *tab,int taille);` renvoyant l'indice de la plus grande valeur du tableau tab de longueur taille.
|
|
|
|
-En utilisant les deux premières fonctions, créer une fonction `fifo* listeDegre(graphe g);` renvoyant une liste des sommets classés selon leur degré.
|
|
|
|
**Question**
|
|
|
|
Pour simplifier le code de Welsh-Powell, écrire une fonction
|
|
`int voisinCouleur(graphe g,int v,int c,int *color)` renvoyant 1 si le sommet v a un voisin de la couleur c dans le tableau color, et 0 sinon.
|
|
|
|
**Question**
|
|
|
|
Enfin, implémentez l'algorithme de Welsh-Powell.
|
|
|
|
Indice : Vous aurez besoin de la liste des sommets triés selon leur degré, mais également d'un lecteur sur cette liste, i.e. un pointeur vers le début de la liste pouvant la parcourir autrement que par des dequeues. |