BFS более лучше

/*за помощь в разборе задачи и объяснение несколько иного, чем у меня в задаче 196, подхода, спасибо Максиму Ткачеву)*/

#include <iostream>
using namespace std;

class vershina
{
public:
vershina* next;
vershina* prev;
    int number;
    int way;
    vershina (int number, int way = 0, vershina* prev = nullptr)
    {
        this->number = number;
        this->way = way;
        this->next = nullptr;
        this->prev = prev;
    }
};

class queue
{
  public:
    queue()
    {
        size = 0;
        head = nullptr;
        tail = nullptr;
    }

    vershina* head;
    vershina* tail;
    int size;

public:
    void push_back(int number, int way = 0, vershina* prev = nullptr)
    {
        vershina* yzel = new vershina(number, way, prev);
        if (head == nullptr)
        {
            head = yzel;
            tail = yzel;
        }
        else
        {
            tail->next = yzel;
            tail = yzel;
        }
        size++;
    }

    void print()
    {
        vershina* current = this->head;
        for (int i = 0; i < size; i++)
        {
            cout << current->number << " ";
            current = current->next;
        }
    }

    vershina* pop_front()
    {
        if (size == 0)
            return 0;

        vershina* result = head;
        head = head->next;
        size--;
        return result;
    }

    int GetSize()
    {
        return size;
    }
};


class Graph
{
public:
    int n;
    bool** arr;
    Graph(int x)
    {
        n = x;
        arr = new bool*[n]{0};

        for (int i = 0; i < n; i++)
            arr[i] = new bool[n]{};
    }

    void new_rebro (int i, int j)
    {
        arr[i][j] = 1;
    }

    void BFS(int start, int finish)
    {
        if (start == finish)
        {
            cout << 0;
            return;
        }

        queue Q;
        vershina* current = new vershina(start);

        for (int i = 0; i < n; i++)
            if (arr[start-1][i] == 1)
                Q.push_back(i+1, 1, current);

        while (Q.GetSize() != 0)
        {
            current = Q.pop_front();
            if (current->number == finish)
            {
                cout << current->way << endl;
                all_way(current, start, current->way);
                return;
            }
            else
                for (int i = 0; i < n; i++)
                    if (arr[current->number - 1][i] == 1)
                        Q.push_back(i + 1, current->way + 1, current);
        }
        cout << -1;
        return;
    }

    void all_way(vershina* start, int stop, int way)
    {
        int* path = new int[way + 1];
        vershina* current = start;
        int i = 0;

        while (current->number != stop)
        {
            path[i] = current->number;
            current = current->prev;
            i++;
        }

        path[way] = stop;

        for (int i = way; i >= 0; i--)
            cout << path[i] << " ";
    }
};

int main()
{
    int n, element, start, finish;
    cin >> n;

    Graph object(n);

    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
        {
            cin >> element;
            if (element == 1)
                object.new_rebro(i, j);
        }

  cin >> start >> finish;
    object.BFS(start, finish);
}