#include "bellman.h"


/***************   Définition des variables globales   ***************/
int ordre;  /* remarque : 
		      les sommets s'appelent 0, 1, ordre-1 */
PERE ** graphe; /* le tableau pour les listes chaînées des pères */
int * distance; /* distance[s] contiendra la distance du sommet
			  s depuis un sommet donné */
int * antecedent; /* antecedent[s] contiendra l'avant-dernier sommet
			    dans un plus court depuis un sommet donné */
int * num;  /* contiendra la numerotation topologique */
int * deNum; /* contiendra l'inverse de la numerotation topologique.
		       Si num[x] = numero, alors deNum{numero] = x. */
/******************   Fin des variables globales  ************/

int main(void)
{
  char nomFichier[50];
  int r;
  PERE * p, * q;
  int i;
  int reussi;
  
  printf("Indiquez le nom du fichier decrivant le graphe\n");
  scanf("%s", &nomFichier);
  construire(nomFichier);
  num = (int *) malloc(ordre * sizeof(int));
  if (num == NULL)
    {
      printf("Pas assez de place\n");
      exit(1);
    }
  deNum = (int *) malloc(ordre * sizeof(int));
  if (deNum == NULL)
    {
      printf("Pas assez de place\n");
      exit(1);
    }
  reussi = triTopologique();
  if (!reussi) printf("Il y a un circuit\n");
  else 
    {
      distance = (int *) malloc(ordre * sizeof(int));
      if (distance == NULL)
	{
	  printf("Pas assez de place\n");
	  exit(1);
	}
      antecedent = (int *) malloc(ordre * sizeof(int));
      if (antecedent == NULL)
	{
	  printf("Pas assez de place\n");
	  exit(1);
	}
      while(1)
	{
	  printf("Depuis quel sommet voulez-vous calculer les distances ? \n");
	  printf("(taper -1 pour terminer) : ");
	  scanf("%d", &r);
	  printf("\n");
	  if (r == -1) break;
	  algoBellman(r); 
	  afficher(r);
	}
      free(distance);
      free(antecedent);
    }

  /*  Désallocation (cette désallocation n'est pas vraiment nécessaire ici
      car la mémoire est de toute façon désallouée à la fin du programme.
      Mais, c'est plus propre, et c'est une bonne habitude de penser à 
      désallouer systématiquement tout espace-mémoire alloué */
  free(num);
  free(deNum);
  for (i = 0; i < ordre; i++)
    {
      p = graphe[i];
      while (p != NULL)
	{
	  q = p;
	  p = p->suivant;
	  free(q);
	}
    }
  free(graphe);
  return 0;
}

/****************  fonction ecrireValeurs  ************
/* Cette fonction sert à afficher à l'écran les valeurs mises 
   dans un tableau dont les indices sont compris entre 0 et ordre - 1.
   Elle sert ici à vérifier le calcul des degrés extérieurs 
   et celui des numéros topologiques. 
   La fonction désalloue, avant de "retourner", le tableau degreExt.*/
void ecrireValeurs(int * tableau)
{
  int i;

  for ( i = 0; i < ordre; i++)
    printf("Pour %d : %d\n", i, tableau[i]);
  printf("\n");
}