/* ==============================================================================
   Programa principal:
   Laboratório: 9 (Grafos)   
   Disciplina: MC202
   Data: 13 / 11 /2001
   =========================================================================== */

#include "global.h"
#include "listas.h"
#include "filaprio.h"
#include "grafos.h"

void Lelinha() {
    char c;
    do { scanf("%c", &c); } while (c !='\n');
  return;
}

int main(){
  Grafo G;
  int n, *D, C;
  Boolean ExisteUmGrafo=false;
  
  int origem,destino;
  char acao, c;

  /* ----------------------------------------------------------------------------
     Declarações e início para verificação do uso da memória dinâmica. 
     A variável 'lixo' está sendo usada apenas para contornar um
     problema do funcionamento das funções da biblioteca 'malloc'. 
     A memória por ela apontada é desalocada logo a seguir!  
   ------------------------------------------------------------------------- */
    
  void *lixo = malloc(1);   
  
  struct mallinfo info;   
  int MemDinInicial, MemDinFinal;

  free(lixo);               
  info = mallinfo();
  MemDinInicial = info.uordblks;
   

  /* ----------------------------------------------------------------------- */  

  do {
    scanf("%c",&acao); 
    printf("Acao: %c ",acao);
    
    switch (acao) {
    case  'a':  
      if (!ExisteUmGrafo) 
	printf("Erro: nâo existe grafo para calcular AGM\n"); 
      else{
	Lelinha();
	printf("\n");
	AGM(G,&C);
	printf("Comprimento da AGM = %d\n",C);
      }
      break;
    case 'c':
      if (!ExisteUmGrafo)
	printf("Erro: nâo existe grafo para calcular CAM\n");
      else{
	scanf("%d %d",&origem,&destino);
	Lelinha();
	printf("de %d para %d \n",origem,destino);
	D=(int *)calloc((n+1),sizeof(int));
	CAM(G,D,origem);
	printf("comprimento do caminho mais curto de %d para %d: %d\n"
	       ,origem,destino,D[destino]);
	free(D);
      }
      break;
      
    case 'r': 
      Lelinha();
      printf("\n");
      InicializaGrafo(&G);
      LeGrafo(&G);
      n=G.n;
      ExisteUmGrafo=true;
      break;
      
    case 'n': 
      Lelinha();
      printf("\n");
      InicializaGrafo(&G);
      LeGrafoNaoOrientado(&G);
      n=G.n;
      ExisteUmGrafo=true;
      break;
      
    case 'l': 
      Lelinha();
      printf("\n"); 
      LiberaGrafo(&G);
      ExisteUmGrafo=false;
      break;
      
    case 'i': 
      Lelinha();
      printf("\n");
      ImprimeGrafo(&G);
      break;
      
    case 't': 
      Lelinha();
      printf("\n\nFim da execução.\n\n");
      break;
      
    case '#': 
      scanf("%c", &c);
      while (c !='\n') { printf("%c",c);  scanf("%c", &c); } 
      printf("\n");
      break;
      
      
    default:   printf("ação %c inexistente \n",acao);	
      Lelinha();
      break;  
    }
  } while (acao != 't');



/* --------------------------------------------------------------------------- */
/* Verificação final do uso da memória dinâmica                                */
/* --------------------------------------------------------------------------- */
    
  info = mallinfo();
  MemDinFinal = info.uordblks;
  if (MemDinInicial!=MemDinFinal)
    printf("\n\nMemória dinâmica não foi totalmente liberada (%d, %d)\n",
                      MemDinInicial,MemDinFinal);
   
/* --------------------------------------------------------------------------- */

  return 0;
} /* main */

     







/* author: Gustavo Sverzut Barbieri (http://www.gustavobarbieri.com.br) */