salve
potete darmi un aiuto...... molto veloce???

/* programma che permetta di calcolare il */
/* percorso tra due fermate di tram o autobus. */
/* In una città vi sono N linee di tram/autobus */
/* che si muovono su F fermate. Ciascuna linea è */
/* identificata da un percorso costituito da una serie di “tratte” */
/* tra fermate consecutive. Ogni fermata è identificata da un nome, mentre */
/* ogni linea è identificata da un numero. */
/* Prima linea: N F */
/* Linee successive, una per “tratta”, nel formato: */
/* | numero_linea | fermata_partenza | fermata_arrivo */
/* Le “tratte” sono da intendersi bidirezionali, ossia una tratta “a b” */
/* indica sia il percorso da “a” a “b” sia il percorso inverso da “b” ad “a” */

e questo è quello che ho scritto:

________questo è header.h__________________________________________ ______
[CODE]
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>



typedef struct VERTEXP{
int n_linea [2];
char nomeFermata[20];
char *adjlist;
int adj; // lo uso come contatore delle adiacenze
}VERTEX;

VERTEX **graph; // adiacenze

int InitGraph(char *DOCUMENTO);
void RicercaRoot(char *partenza, char *arrivo, VERTEX *graph)
void RicercaArrivo(VERTEX *graph, char *arrivo)
void best_fit(int * visited, int visitedTemp)
[CODE]
_________________________________
questo il C.
_________________________________________
codice:
#include "grafi.h"
#define DOCUMENTO "linee.txt"


int fermate;
int linee;
int *visited;
int visitedN_elementi;
int *Best;
int BestN_elementi;


int main()
{
    printf("\n\n Inserisci la fermata di partenza: ");
    scanf("%s",partenza);
    printf("\n Inserisci la fermata di arrivo: ");
    scanf("%s",arrivo);
  
    if (InitGraph(DOCUMENTO)==1 )
      RicercaRoot(partenza, arrivo, graph);
}

/* funzione di apertura del file e creazione delle adiacenze */
int InitGraph(const DOCUMENTO)
{ 
    FILE *fin;
    int nadj, n, i, j,x,y,k;
    char fermP[20], fermA[20];
    char **vett;
    
if( (fin=fopen( DOCUMENTO, "r")) == NULL)
   { 
    printf( "Errore in apertura file %s\n", name);
    return(0); 
   }
   
/* lettura della prima riga */
/* dove trovo il numero delle linee e il numero delle fermate */
fscanf( fin, "%d %d \n", &linee,&fermate );

/* alloco il numero di fermate richieste dal file */
visited=(int *)malloc(fermate*sizeof(int));

/* allocazione dinamica , creazione del grafo */
if( (graph = (VERTEX **)malloc( fermate * sizeof( VERTEX *))) == NULL)
  { 
           printf( "Errore in allocazione graph\n");
           return( 0); 
  }
  
/* lettura delle successive fermate, ho utilizzato questo ciclo perchè non*/
/* conosco di preciso quanti dati devo leggere dal file */  
i=0;
n=0;
while(n<=3)
{  
     /* lettura della linea, della fermata di partenza e quella di arrivo */
     /* rispettivamente: numero della linea fermata di partenza */
     /* e fermata di arrivo */
  
     fscanf( fin, "%d %s %s \n", &n, fermP, fermA ); 
     i++;
    
    if( ( graph[i] = (VERTEX *)malloc( sizeof( VERTEX ))) == NULL)
       { printf( "Errore in allocazione vertice %d\n", i);
         return( 0); 
         }
         
  graph->nomeFermata[i] = strdup(fermP);
  graph->adjlist[i] = strdup(fermA);
  graph->adj = 1;
  
  // controllo se le fermate di partenza estratte esistono già, controllo a ritroso
  for(x=i; x<0; x--)
    { if(strcmp(fermP,graph->nomeFermata[x])==0)
        {  // conto le adiacenze
          for(y=0; y<graph->adj[x][y]; y++)
            ;
            graph->adjlist[x][y] = strdup(fermA); // alla fine aggiungo l'ultima adiacenza trovata
            ++graph->adj[x][y];  // incremento il contatore delle adiacenze
        }
    }
    
  // controllo se le fermate di arrivo sono già state estratte
  for(x=i; x<0; x--)
    { if(strcmp(fermP,graph->adjlist[x])==0)
        {// conto le adiacenze
          for(y=0; y<graph->adj[x][y]; y++)
              ;
          graph->adjlist[x][y] = strdup(fermP);// aggiungo l'adiacenza
          ++graph->adj[x][y];   // incremento il contatore delle adiacenze
        }
    }
  }  
    
fclose( fin);
return( 1);
}
}




/* funzione che mi ricerca la root, praticamente la fermata di partenza*/
void RicercaRoot(char *partenza, char *arrivo, VERTEX *graph)   
{
     //se la trovo subito nel root, ho finito
     if(strcmp(graph->nomeFermata,partenza)==0  || null)
     {
            RicercaArrivo(*graph, *arrivo);   //-------------------punto per la ricerca vera e propria
     }
     
     //
     if(strcmp(graph->nomeFermata,partenza)!=0)
     {
             return RicercaRoot(VERTEX *graph->adjlist, char *arrivo);
     }else
         {
             return RicercaRoot(VERTEX *graph->adjlist+1, char *arrivo);    //--------------------------------------
          }
}// fine searchRoot


/* funzione che mi ricerca la fermata di arrivo*/
 void  RicercaArrivo(VERTEX *graph, char *arrivo)
  {
       
       //se la trovo subito nel root, ho finito
     if(strcmp(graph->nomeFermata,arrivo)==0  || null)
     {
            return graph->n_linea;
            
            //---------------confronto temp con best e nel caso aggiorno     
            best_fit(visited, visitedTemp);
            
            }
     
     //
     if(strcmp(graph->nomeFermata,arrivo)!= 0 )
     {
             return RicercaArrivo(VERTEX *graph->adjlist, char *arrivo);
             visited=graph->n_linea;
             visitedN_elementi++;
             ++visited;
             
     }else
         {
             return RicercaArrivo(VERTEX *graph->adjlist+1, char *arrivo);    //--------------------------------------
             visited=graph->n_linea;
             visitedN_elementi++;
             ++visited;
         }
}

/* funzione di ricerca del percorso migliore */
  void	best_fit(int * visited, int visitedTemp)
{
	int	i;

	if( visitedN_elemnti==bestN_elementi )
	{
        /*se il numero di elementi del best è uguale lo stampo semplicemnte		*/
        
		---------------------------------------------------------------
	}
	
	if(visitedN_elemnti <bestN_elementi)
	{
		//aggiorno best, copia vettore vettore
		// copio visited in best
		visitedN_elemnti=bestN_elementi
		for( i = 0; i < visitedN_elementi; i++ )
				best[i] = visited[i];
		
	}
}
......