Dijkstra su grafo diretto - 0/0

Aiuto
1

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;
}
2

C’è un’implementazione di Dijsktra molto più veloce:

bool visited[10001];
int dist[10001];
vector <pair<int,int>> adj[10001];
priority_queue<pair<int,int>>coda; 


	for(int i=1;i<=n;i++){
		dist[i] = 10000000;
	}
	dist[inizio] = 0;
	coda.push({0,inizio});
	int a;
	while(!coda.empty()){
		a = coda.top().second;
		coda.pop();
		if(visited[a]) continue;
		visited[a] = true;
		for(auto v : adj[a]){ 
			if(dist[a] + v.second < dist[v.first]){
				dist[v.first] = dist[a] + v.second;
				coda.push({-dist[v.first],v.first});
			}	
		} 
	}

Spero di esserti stato d’aiuto