Dijkstra - BFS

#include <iostream>
#include <queue>
#include <stack>

int num_of_vertex, *map, (*table)[2];
bool *visited_vertex;

void dijkstra(int start, int end) {
    std::queue<int> q;
    std::stack<int> path;

    q.push(start);
    visited_vertex[0] = true;

    while(!q.empty()) {
        int vertex = q.front();
        q.pop();
        visited_vertex[vertex] = true;

        for(int i = 0; i < num_of_vertex; ++i) {
            if(map[vertex * num_of_vertex + i] > 0 and visited_vertex[i] == false) {
                if(table[i][0] == -1 or
                  (table[vertex][0] + map[vertex * num_of_vertex + i] < table[i][0])) {
                      table[i][0] = table[vertex][0] + map[vertex * num_of_vertex + i];
                      table[i][1] = vertex;
                  }

                q.push(i);
            }
        }
    }

    for(int i = end;;i = table[i][1]) {
        if(i == -1) return;

        path.push(i);

        if(table[i][0] == 0) break;
    }

    std::cout << "Minumum cost: " << table[end][0] << "\n";
    std::cout << "Path: ";
    while(true) {
        std::cout << path.top();

        path.pop();

        if(path.empty()) break;
        else std::cout << " -> ";
    }
}

int main() {
    int num_of_edge, start_vertex, end_vertex;

    std::cin >> num_of_vertex;
    std::cin >> num_of_edge;
    std::cin >> start_vertex;
    std::cin >> end_vertex;

    map = new int[num_of_vertex * num_of_vertex];

    int n = num_of_vertex * num_of_vertex;
    for(int i = 0; i < n; ++i) map[i] = 0;

    visited_vertex = new bool[num_of_vertex];
    for(int i = 0; i < num_of_vertex; ++i)
        visited_vertex[i] = false;

    table = new int[num_of_vertex][2];
    for(int i = 0; i < num_of_vertex; ++i) {
        for(int j = 0; j < 2; ++j) {
            table[i][j] = -1;
        }
    }

    table[start_vertex][0] = 0;

    //generate adjacency matrix
    int source, destination, weight;
    for(int i = 0; i < num_of_edge; ++i) {
        std::cin >> source;
        std::cin >> destination;
        std::cin >> weight;

        map[source + destination * num_of_vertex] = weight;
        map[destination + source * num_of_vertex] = weight;
    }

    std::cout << "\n";

    dijkstra(start_vertex, end_vertex);

    return 0;
}