matrici.c

Floyd-wharshall algoritm for the shortest path problem. I wrote this in C. It s easy to compile and

#include "in.h"
#include "func.h"
/*----------------------------------------------------------------------
 Funzioni per la rappresentazione delle matrici di adiacenza
----------------------------------------------------------------------*/

void am_delete (ADJMAT *am)
{                               /* --- Cancella una matrice */
  int i;                        /* Contatore  */

  for (i = am->size; --i >= 0;) /* Ciclo per eliminare le linee di una mat*/
    if (am->mat[i]) free(am->mat[i]);
  free(am->mat);                /* Libera le linee della matrice */
  free(am);    			/* E lo spazio occupato dalla struct */               
}  /* am_delete() */

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

ADJMAT* am_create (int size)
{                               /* --- Crea una matrice di adiacenza  */
  int    i;                     /* contatore  */
  ADJMAT *am;                   /* Crea una struct per memorizzare la mat */

  am = (ADJMAT*)malloc(sizeof(ADJMAT));
  if (!am) return NULL;         /* alloca la memoria */
  am->mat = (int**)calloc(size, sizeof(int*));
  if (!am->mat) { free(am); return NULL; }
  am->size  = size;             /* Alloca la memoria per le linee della mat */
  am->vtcnt = am->edcnt = 0;    /* e inizializza i campi*/
  for (i = size; --i >= 0; ) {  
    am->mat[i] = (int*)malloc(size *sizeof(int));
    if (!am->mat[i]) { am_delete(am); return NULL; }
  }                         
  return am; 
}  /* am_create() */

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

int am_adapt (ADJMAT *am, int size)
{                               /* --- Fa un check e adatta la matrice alla grandezza
                                       specificata */
  int  i;                       /* contatore */
  void *new;                    /* il nuovo vettore (allargato) */
  int  tmp;                     /* buffer temporaneo*/

  if (am->size >= size)         /* se la matrice 猫 grande abbastaza*/
    return 0;                   /* Stoppa la funzione */
  tmp = am->size +BS_MATRIX;    /* processa la grandezza del nuovo vettore */
  if (tmp > size) size = tmp;  
  new = realloc(am->mat, size *sizeof(int*));
  if (!new) return -1;  
  am->mat = new;                /* setta il nuovo vettore */
  for (i = am->size; i < size; i++)
    am->mat[i] = NULL;          /* pulisci i nuovi elementi del vettore */
  for (i = size; --i >= 0; ) {
    am->mat[i] = (int*)realloc(am->mat[i], size *sizeof(int));
    if (!am->mat[i]) break;  
  }        
  if (i >= 0) {  		/* Se c'猫 un errore ritorna -1 */          
    for (i = am->size; i < size; i++)
      if (am->mat[i]) free(am->mat[i]);
    return -1;                 
  } 
  am->size = size;  
  return 0;  
}  /* am_adapt() */

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

int am_addvert (ADJMAT *am, int cnt)
{                               /* --- aggiungi un nuovo vertice alla matrice */
  int i;                        /* contatore */

  if (am_adapt(am, am->vtcnt +cnt) != 0)  /* adatta la matrice */
    return E_NOMEM;             /* se