Salve! Qualcuno mi può dire perché questo codice non funziona?
Anche se provando in locale funziona?
#include <iostream>
#include <fstream>
#include <vector>
#define BIANCO 1
#define NERO 0
#define INFINITO 0x7FFFFF
using namespace std;
struct ARCO
{
int IDNodo; //Identificativo del nodo
long long Peso; //Peso dell'arco
ARCO *Next;
};
struct NODO
{
int Colore; //Colore del nodo
int ID; //Identificativo
int Potenziale; //Potenziale del nodo
ARCO *Ad; //lista degli adiacenti
};
struct CODA
{
int ID;
int Pot;
};
void InitNodi ( NODO *Grafo, int N );
void AggiungiArco ( NODO *Grafo, int A, int B, int P );
void Push ( NODO &N, int B, int P );
int Dijskstra ( NODO *Grafo, int Source, int Dest );
void AccodaAdiacenti( vector<CODA> &C, NODO &N, NODO *Grafo );
int Minimo ( vector<CODA> C );
main()
{
ifstream In("input.txt");
ofstream Out("output.txt");
int N; //Numero di vertici
int M; //Numero di archi
int S; //Sorgente
int D; //Destinazione
NODO *Grafo;
In >> N;
In >> M;
In >> S;
In >> D;
//N+1 perche' ID parte da 1
Grafo = new NODO[N+1];
//inizializzazione del grafo
InitNodi(Grafo, N);
int A, B, P;
for (int i=0; i<M; i++)
{
In >> A;
In >> B;
In >> P;
AggiungiArco(Grafo, A, B, P);
}
//Out << Dijskstra(Grafo, S, D);
cout << endl << Dijskstra(Grafo, S, D);
}
/*====================================
Inizializziamo i nodi con le loro,
informazioni di partenza
------------------------------------*/
void InitNodi(NODO *Grafo, int N)
{
for (int i=1; i<=N; i++)
{
Grafo[i].Colore = BIANCO;
Grafo[i].ID = i;
Grafo[i].Potenziale = INFINITO;
Grafo[i].Ad = NULL;
}
}
/*======================================================
Aggiunge un arco diretto da A a B di un certo peso P
------------------------------------------------------*/
void AggiungiArco (NODO *Grafo, int A, int B, int P)
{
Push(Grafo[A], B, P);
Push(Grafo[B], A, P);
}
/*=========================================
Inseriamo in testa alla lista il nodo
-----------------------------------------*/
void Push(NODO &N, int B, int P)
{
ARCO *Nuovo;
Nuovo = new ARCO;
Nuovo->IDNodo=B;
Nuovo->Peso=P;
Nuovo->Next = N.Ad;
N.Ad = Nuovo;
}
/*=====================================
Algoritmo di DIJKSTRA
-------------------------------------*/
int Dijskstra (NODO *Grafo, int Source, int Dest)
{
int ContNodi=0;
vector<CODA> C;
bool Trovato=false;
int Ora;
//Assegniamo alla Sorgente colore nero
//e potenziale 0
Grafo[Source].Colore = NERO;
Grafo[Source].Potenziale = 0;
/*===================================================
Finche'(!Trovato)
-Riempi Coda con adiacenti e calcola potenziale
-Cerca il minimo dei potenziali
-Spostati sul minimo e coloralo di nero
if(minimo=dest)
Trovato=true;
Svuota Coda
---------------------------------------------------*/
Ora = Source;
while(!Trovato)
{
AccodaAdiacenti(C, Grafo[Ora], Grafo);
Ora = Minimo(C);
Grafo[Ora].Colore=NERO;
cout << Ora << endl;
ContNodi++;
if(Ora==Dest)
Trovato=true;
else
C.clear();
}
return ContNodi;
}
/*===================================================
Mettiamo in coda tutti gli adiacenti
---------------------------------------------------*/
void AccodaAdiacenti(vector<CODA> &C, NODO &N, NODO *Grafo)
{
ARCO *P;
CODA App;
for (P = N.Ad; P; P = P->Next)
{
if (Grafo[P->IDNodo].Colore==BIANCO)
{
App.ID = P->IDNodo;
//il potenziale di questo nodo è uguale al peso
//dell'arco + il potenziale del padre
App.Pot=P->Peso+N.Potenziale;
Grafo[P->IDNodo].Potenziale = App.Pot;
C.push_back(App);
}
}
}
/*===============================================
Restituisce l'ID del nodo con potenziale minimo
-----------------------------------------------*/
int Minimo (vector<CODA> C)
{
int N = C.size();
int Pos;
Pos=0;
for (int i=1; i<N; i++)
{
if(C[i].Pot<C[Pos].Pot) Pos = i;
}
return C[Pos].ID;
}