#include <stdio.h>
#include <stdlib.h>
#include "variables.h"

//Funcion Calc_N_Vertices: Calcula la cantidad de vértices que tiene el grafo.
//Variables de entrada   : Descriptor del archivo con el grafo.
//Valor devuelto	 : Cantidad de vértices en el grafo.
int Calc_N_Vertices (FILE *GRAFODATA)
{
  int maximo = -1,		//Máximo número de vértice.
      vertice;			//Vertice actual.
  float fvertice;		//Variable para guardar lo leído desde el arhivo.

  rewind (GRAFODATA);		//Volver al inicio del archivo.

  //A continuación, calculamos la cantidad de vértices que contiene el grafo, de manera de crear, dinámicamente,
  //la matriz de adyacencias. Para hacer esto, buscamos el número de vértice más alto, aprovechándonos del hecho
  //que dichos números son correlativos y comienzan en 0.
  while (fscanf(GRAFODATA, "%f", &fvertice) != EOF) //Para todos lo vértices del archivo...
    {
      vertice = (int)fvertice;	//Aprovechando que los pesos están en ]0;1[, hacemos un cast para eliminarlos
      if (vertice > maximo)	//...¿es mayor que el mayor número de vértice hallado hasta el momento?
       {
         maximo = vertice;	//Entonces el último vértice leído es el máximo.
       }//EndIf
    }//EndWhile
  return (maximo+1);		//Devolver la cantidad de vértices.
}//EndCalc_N_Vertices


//Función Crear_Matriz 	: Crea una matriz de adyacencias.
//Variables de entrada 	: Descriptor del archivo con el grafo.
//Variables de salida  	: La matriz de adyacencia.
//Valor devuelto 	: La cantidad de vértices en el grafo.
MatrizT Crear_Matriz (FILE *GRAFODATA, int N_Vertices)
{
  MatrizT Matriz;
  int vertice1,		//Primer vértice
      vertice2,		//Segundo vértice
      i,j;		//Contadores
  float peso;		//Peso del arco

  //Ahora creamos el espacio en memoria para la matriz.
  Matriz = malloc (N_Vertices*sizeof(float));		//Ahora creamos el espacio para la matriz...
  for (i = 0; i < N_Vertices; i++)
    {
      Matriz[i] = malloc (N_Vertices*sizeof(float));
      for (j = 0; j < N_Vertices; j++)
        {
          Matriz[i][j] = -1.0;				//...y la reseteamos con un valor que indique que...
        }//EndFor					//...no hay arco
    }//EndFor;

  //Ahora que tenemos el espacio en memoria listo, cargamos los datos a partir del archivo...
  rewind (GRAFODATA);					//Primero que nada, volvemos al principio...
  while (fscanf(GRAFODATA, "%d %d %f", &vertice1, &vertice2, &peso) != EOF)
     {
        Matriz[vertice1][vertice2] = peso;		//Guardamos el peso correspondiente a un arco en la matriz...
        Matriz[vertice2][vertice1] = peso;		//...y su posición traspuesta
     }
  return (Matriz);					//Devolver la matriz de adyacencias.
}//EndCrear_Matriz


//Función Destruir_Matriz: Destruye una matriz de adyacencias y libera la memoria.
//Variables de entrada 	 : La matriz de adyacencia, cantidad de vértices.
void Destruir_Matriz (MatrizT Matriz, int N_Vertices)
{
  int i;				//Contador

  for (i = 0; i < N_Vertices; i++)	//Liberar memoria.
    {
      free (Matriz[i]);
    }//EndFor
  free (Matriz);
}//EndDestruir_Matriz