Esempio n. 1
0
void plus_courte_chaine (tGraphe graphe, tNomSommet s, int d[], tNumeroSommet pred[]) {
  int i;
  tTabCouleurs tabCouleurs;
  tFileSommets file;
  tNumeroSommet numSommetx, numSommety;
  file = fileSommetsAlloue();
  for(i=0; i<graphe->nbSommets; i++){
    tabCouleurs[i]=BLEU;
  }
  while(!(fileSommetsEstVide(file))){
    fileSommetsDefile(file);
  }
  numSommetx = grapheChercheSommetParNom(graphe,s);
  numSommety = grapheChercheSommetParNom(graphe,s);
  d[numSommetx] = 0;
  tabCouleurs[numSommetx] = VERT;
  fileSommetsEnfile(file, numSommetx);
  while(!(fileSommetsEstVide(file))){
    numSommetx = fileSommetsDefile(file);
    for(i=0; i<grapheNbVoisinsSommet(graphe,numSommetx); i++){
      numSommety = grapheVoisinSommetNumero(graphe,numSommetx,i);
      if(tabCouleurs[numSommety]==BLEU){
	tabCouleurs[numSommety]=VERT;
	fileSommetsEnfile(file, numSommety);
	d[numSommety] = d[numSommetx] + 1;
	printf("Incr d[%i]\n", numSommety);
	pred[numSommety] = numSommetx;
      }
    tabCouleurs[numSommetx]=ROUGE;
    }
  }
  fileSommetsLibere(file);
}
Esempio n. 2
0
//
// paramètres :
//
// graphe = graphe orienté
// s = sommet de départ
// result = tableau de sommets accessibles depuis s (result[i]=1 si i est accessible depuis s, -1 sinon)
//
void parcours_largeur(tGraphe graphe, tNumeroSommet s, int result[])
{
  // nombre de sommets du graphe
  unsigned int n = grapheNbSommets(graphe);
  // le tableau de couleurs
  tCouleur tabCouleurs[n];
  // la file
  tFileSommets file;
  // sommets x,y
  tNumeroSommet x, y;
  // variable de parcours
  unsigned int i;

  /* initialisation */

  // colorier tous les sommets en bleu
  for (i=0; i<n; i++)
    {
      tabCouleurs[i] = BLEU;
    }
  // initialiser la file
  file = fileSommetsAlloue();
  // colorier s en vert
  tabCouleurs[s] = VERT;
  // enfiler s
  fileSommetsEnfile(file, s);

  /* boucle principale */

  // tant que la file n'est pas vide
  while (!fileSommetsEstVide(file))
    {
      // x = tête de file
      x = fileSommetsDefile(file);
      // parcours de tous les successeurs
      for (i=0; i<grapheNbSuccesseursSommet(graphe,x); i++)
        {
	  // y est le nom du successeur courant
	  y = grapheSuccesseurSommetNumero(graphe, x, i);
	  if (tabCouleurs[y] == BLEU)
            {
	      // colorier y en vert et l’enfiler
	      tabCouleurs[y] = VERT;
	      fileSommetsEnfile(file, y);
	    }
        }
      tabCouleurs[x] = ROUGE;
    }

  // libérer la file
  fileSommetsLibere(file);

  // tous les sommets en rouge sont accessibles
  for (i=0; i<n; i++)
    {
      if (tabCouleurs[i] == ROUGE) result[i] = 1;
      else result[i] = -1;
    }
}
Esempio n. 3
0
void parcoursEnLargeurCouleurs(tGraphe graphe, tNumeroSommet sommetDepart, tTabCouleurs tableauCouleurs) {
	tFileSommets fileSommets;
	// variable contenant les numéros des sommets défilés
	tNumeroSommet x;
	// variable contenant les voisins de x
	tNumeroSommet y;
	// variable contenant les noms des sommets affichés
	tNomSommet nomSommet;
	// indice de boucle
	int i;
	grapheRecupNomSommet(graphe,sommetDepart,nomSommet);
	fileSommets = fileSommetsAlloue();
	// on colorie le sommet de départ en vert et tous les autres sommets en bleu
	for (i = 0 ; i < grapheNbSommets(graphe) ; i++) {
		tableauCouleurs[i] = BLEU;
	}
	for (i = 0 ; i < grapheNbSommets(graphe) ; i++) {
		if (i == sommetDepart) {
			tableauCouleurs[i] = VERT;
			// on affiche le graphe au départ (quand tous les sommets) sont bleus et le sommet de départ est vert
			graphe2visuCouleurs(graphe,"visuCouleurs",tableauCouleurs);
		}
	}
	// on enfile le sommet de départ
	fileSommetsEnfile(fileSommets,sommetDepart);
	while (!fileSommetsEstVide(fileSommets)) {
		// on défile le dernier sommet enfilé
		x = fileSommetsDefile(fileSommets);
		// on parcourt la liste des voisins de x
		for (i = 0 ; i < grapheNbVoisinsSommet(graphe,x) ; i++) {
			// on récupère le numéro du i-ème voisin de x
			y = grapheVoisinSommetNumero(graphe,x,i);
			// s'il est bleu, on le colorie en vert et on l'enfile
			if (tableauCouleurs[y] == BLEU) {
				tableauCouleurs[y] = VERT;
				// on affiche le graphe car il y a eu un changement de couleur
				graphe2visuCouleurs(graphe,"visuCouleurs",tableauCouleurs);
				fileSommetsEnfile(fileSommets,y);
			}
		}
		// on colorie x en rouge et on affiche le nom de sommet correspondant
		tableauCouleurs[x] = ROUGE;
		// on affiche le graphe car il y a eu un changement de couleur
		graphe2visuCouleurs(graphe,"visuCouleurs",tableauCouleurs);
		grapheRecupNomSommet(graphe,x,nomSommet);
	}
	printf("\n");
	// on libère l'espace mémoire occupé par le graphe car on n'en a plus besoin
	grapheLibere(graphe);
}
Esempio n. 4
0
/* fait le parcours en largeur vu en cours et affiche la liste des sommets dans l'ordre de parcours */
void parcoursEnLargeur(tGraphe graphe, tNumeroSommet sommetDepart) {
	// le tableau de couleurs et la file de sommets
	tTabCouleurs tableauCouleurs;
	tFileSommets fileSommets;
	// variable contenant les numéros des sommets défilés
	tNumeroSommet x;
	// variable contenant les voisins de x
	tNumeroSommet y;
	// variable contenant les noms des sommets affichés
	tNomSommet nomSommet;
	// indice de boucle
	int i;
	grapheRecupNomSommet(graphe,sommetDepart,nomSommet);
	printf("Parcours en largeur avec %s comme sommet de départ :",nomSommet);
	fileSommets = fileSommetsAlloue();
	// on colorie le sommet de départ en vert et tous les autres sommets en bleu
	for (i = 0 ; i < grapheNbSommets(graphe) ; i++) {
		if (i == sommetDepart)
			tableauCouleurs[i] = VERT;
		else
			tableauCouleurs[i] = BLEU;
	}
	// on enfile le sommet de départ
	fileSommetsEnfile(fileSommets,sommetDepart);
	while (!fileSommetsEstVide(fileSommets)) {
		// on défile le dernier sommet enfilé
		x = fileSommetsDefile(fileSommets);
		// on parcourt la liste des voisins de x
		for (i = 0 ; i < grapheNbVoisinsSommet(graphe,x) ; i++) {
			// on récupère le numéro du i-ème voisin de x
			y = grapheVoisinSommetNumero(graphe,x,i);
			// s'il est bleu, on le colorie en vert et on l'enfile
			if (tableauCouleurs[y] == BLEU) {
				tableauCouleurs[y] = VERT;
				fileSommetsEnfile(fileSommets,y);
			}
		}
		// on colorie x en rouge et on affiche le nom de sommet correspondant
		tableauCouleurs[x] = ROUGE;
		grapheRecupNomSommet(graphe,x,nomSommet);
		printf(" %s",nomSommet);
	}
	printf("\n");
}
Esempio n. 5
0
void parcoursLargeur(tGraphe graphe, tNomSommet nom, tTabCouleurs tabCouleurs)
{

  tFileSommets file;
  tNumeroSommet s, x, y;
  char * fichier;
  int i, cpt;

  cpt=0;
  fichier=malloc(sizeof(char[20]));
  s = grapheChercheSommetParNom(graphe, nom);
  file = fileSommetsAlloue();
  for(i = 0; i <= grapheNbSommets(graphe) - 1; i++)
  {

    if(i != s)
      tabCouleurs[i] = BLEU;
  }
  tabCouleurs[s] = VERT;
  graphe2visuCouleurs(graphe, "img/visu0.ps", tabCouleurs);
  fileSommetsEnfile(file, s);
  while(!fileSommetsEstVide(file))
  {

    x = fileSommetsDefile(file);
    for(i = 0; i <= grapheNbVoisinsSommet(graphe, x) - 1; i++)
    {

      y = grapheVoisinSommetNumero(graphe, x, i);
      if(tabCouleurs[y] == BLEU)
      {
        tabCouleurs[y] = VERT;
        fileSommetsEnfile(file, y);
      }

    }
    tabCouleurs[x] = ROUGE;
    cpt++;

    sprintf(fichier, "img/visu%d.ps",cpt );

    graphe2visuCouleurs(graphe, fichier, tabCouleurs);
  }
}
Esempio n. 6
0
void plus_courte_chaine(tGraphe graphe,tNumeroSommet sommetActuel){
	/* Déclarations */
	int nbVi, i;
	int coulSommet[MAX_SOMMETS];
	int d[MAX_SOMMETS];
	tNumeroSommet pred[MAX_SOMMETS];
	/* Initialisations */
	printf("Recherche à partir du sommet %d.\n", sommetActuel);
	tFileSommets file = fileSommetsAlloue();
  for (i=0;i<MAX_SOMMETS;i++){
		coulSommet[i] = BLEU;
		d[i] = -1;
		pred[i] = -1;
	}
	while (! fileSommetsEstVide(file)){
		fileSommetsDefile(file);
	}
	coulSommet[sommetActuel] = VERT;
	d[sommetActuel] = 0;
	fileSommetsEnfile(file, sommetActuel);
	/* Début de la boucle */
	while (! fileSommetsEstVide(file)){
		sommetActuel = fileSommetsDefile(file);
		nbVi=grapheNbVoisinsSommet(graphe, sommetActuel);
		for(i=0;i<nbVi;i++){
			if (coulSommet[i] == BLEU){
				coulSommet[i] = VERT;
				fileSommetsEnfile(file, i);
				d[i] = d[sommetActuel] +1;
				pred[i] = sommetActuel;
			  printf("sommet %d : distance = %d, prédécesseur = %d.\n", i, d[i], pred[i]);
			}
		}
		coulSommet[sommetActuel] = ROUGE;
	}
	/* Libération de la mémoire */
	fileSommetsLibere(file);
}
Esempio n. 7
0
void affiche_parcours_largeur(tGraphe graphe, tNumeroSommet num_sommet)
{
    tFileSommets file;
    tNomSommet nom_sommet;
    tNumeroSommet current_voisin;
    tTabCouleurs tab_couleurs;
    int i, nb_sommets, voisins;
    char *argv[3];
    argv[0] = "evince";
    argv[1] = output;
    argv[2] = NULL;

    switch(fork()) {
    case -1:
        perror("fork");
        exit(EXIT_FAILURE);
    case 0 :
        execvp(argv[0], argv);
        halt("Error evince");
        exit(EXIT_FAILURE);
    default:
        file = fileSommetsAlloue();
        nb_sommets = grapheNbSommets(graphe);
        if(verbose)
            printf("Nb sommets : %d\n", nb_sommets);
        for(i = 0 ; i < nb_sommets; i++) {
            tab_couleurs[i] = BLEU;
        }

        fileSommetsEnfile(file, num_sommet);
        tab_couleurs[num_sommet] = VERT;
        grapheRecupNomSommet(graphe, num_sommet, nom_sommet);
        printf("Sommet %s empilé\n", nom_sommet);
        graphe2visu(graphe, output, tab_couleurs);

        sleep(2);
        while(!fileSommetsEstVide(file)) {

            voisins = grapheNbVoisinsSommet(graphe, num_sommet);
            if(verbose)
                printf("Nb voisins : %d\n", voisins);

            for(i = 0; i < voisins; i++) {
                current_voisin = grapheVoisinSommetNumero(graphe, num_sommet, i);
                if(tab_couleurs[current_voisin] == BLEU ) {
                    fileSommetsEnfile(file, current_voisin);
                    tab_couleurs[current_voisin] = VERT;
                    grapheRecupNomSommet(graphe, current_voisin, nom_sommet);
                    printf("Sommet %s empilé\n", nom_sommet);
                    graphe2visu(graphe, output, tab_couleurs);
                    sleep(2);
                }
                if(verbose)
                    printf("voisin num %d\n", current_voisin);
            }
            tab_couleurs[num_sommet] = ROUGE;
            num_sommet = fileSommetsDefile(file);
            grapheRecupNomSommet(graphe, num_sommet, nom_sommet);
            if(verbose)
                printf("Sommet %s depilé\n", nom_sommet);
            graphe2visu(graphe, output, tab_couleurs);
            sleep(2);

        }
        fileSommetsLibere(file);


        wait(NULL);
    }



}
Esempio n. 8
0
/*calcule les tableaux d et pred*/
void plus_courte_chaine(tGraphe graphe, tNomSommet s) {	
/*creation de file et on la libere*/
	tFileSommets file;
	file = fileSommetsAlloue();
	fileSommetsLibere(file);



	int d[MAX_SOMMETS];
	tNumeroSommet pred [MAX_SOMMETS];
	tCouleur tTabCouleurs[MAX_SOMMETS];
	tNomSommet nomSommet;
   	int nbSommets = grapheNbSommets(graphe);

/*colorier en bleu tous les sommets sauf s*/
	   while(i<nbSommets){
	      grapheRecupNomSommet(graphe,i,nomSommet);
	      if (nomSommet != s){
	      	tTabCouleurs[i] = 1;
        }
	      else 
	      {
	      	tTabCouleurs[i] = 2;
	      }    	
	      i++;
    }
/*d(s) =0 et pred(s) est indéfini*/
		d[s] = 0;
		pred[s]=-1;

/*colorier s en vert et enfiler*/

 tNumeroSommet indexSommetS = grapheChercheSommetParNom(graphe,s);
      tTabCouleurs[indexSommetS] = 2;
      printf("Couleur du sommet S avant enfilage : %s\n",couleur_sommet(tTabCouleurs[indexSommetS]));
      fileSommetsEnfile(file,indexSommetS);

    while (!fileSommetsEstVide(file)){
    	tNumeroSommet x;
    	x = fileSommetsDefile(file);

    	      if(grapheNbVoisinsSommet(graphe,x) != 0){
    	      	for (int j = 0; j < grapheNbVoisinsSommet(graphe,x);j++){
	    	      	tNumeroSommet y;
	    	      	y = grapheVoisinSommetNumero(graphe,x,j); 
	    	      		if (tTabCouleurs[y] == 1){
	    	      		  tTabCouleurs[y] = 2;
	   			    		  fileSommetsEnfile(file, y);
	    	      		}
    	     	  }
    	      }  
/*faire d(y)=d(x)+1 et pred(y) := x*/


/*colorier x en rouge*/
   	  tTabCouleurs[x] = 0; 
    }







/*affichage du plus court chemin*/


}