Algoritmos - Hoja de Ruta de consulta - primero en amplitud de recorrido

#include <cassert> 
#include <vector>

plantilla <nombre de tipo gráfico>
 clase ShortestPath
{
privada :
    Graph y G;
     int S; // un cierto punto 
    BOOL * visitada;
     int * de ; // camino 
    int * la ord; // distancia más corta

pública :
    ShortestPath (Gráfico y gráfico, int S): G (Graph) {
         // el algoritmo de inicialización 
        Assert (S> = 0 && S < GV ());

        visitado = nuevo  bool [GV ()];
        de = nuevo  int [GV ()];
        ord = nuevo  int [GV ()];

        para ( int i = 0 ; i <GV (); i ++ ) {
            visitado [i] = false ;
            de [i] = - 1 ;
            palabra [i] = - 1 ;
        }
        este -> s = s;

        Queue < int > Q;
         // primero en amplitud algoritmo a la figura no camino más corto 
        q.push (s);
        visitado [s] = verdadero ;
        ord [S] = 0 ;
        mientras que (! q.empty ())
        {
            int v = q.front ();
            q.pop ();
            TypeName Graph :: adj adjIterator (G, v);
            para ( int i = adj.begin () ;! adj.end (); i = adj.next ()) {
                 si (! visitado [i]) {
                    q.push (i);
                    visitado [i] = verdadero ;
                    de [i] = v;
                    palabra [i] = palabras [v] + 1
                }
            }
        }
        

    };
    ~ Path () {
         delete [] visitado;
        eliminar [] a partir ;
        eliminar [] ord;
    }
    // si hay un camino de s a W 
    BOOL hasPath ( int W) {
        assert (w > = 0 && w < GV ());
        devolver visitado [w];
    }

    // es el número de trayectorias desde s a w 
    void trayectoria ( int w, Vector < int > & VEC) {
        pila < int > s;
        
        int p = w;
        mientras que (p = - 1 ) {
            s.push (p);
            p = de [p];
        }
        vec.clear ();
        mientras que (! s.empty ()) {
            vec.push_back (s.top ());
            s.pop ();
        }
    }
    // la ruta de impresión 
    vacío showPath ( int W) {
        vector < int > vec;
        trayectoria (w, vec);
        para ( int i = 0 ; i <vec.size (); i ++ ) {
            cout << vec [i];
            si (i == vec.size () - 1 )
                cout << endl;
            otra cosa 
                cout << " -> " ;
        }

    }
    int lenth ( int w) {
        assert (w > = 0 && w < GV ());
        volver ord [w];
    }

};