int dijkstra(int n, int src, int dst, unordered_map<int, vector<vector<int>>>& adj) {
    priority_queue<vector<int>> pq;
    vector<int> cost(n, INT_MAX);
    cost[src] = 0;
    pq.push({src, 0});
    while (!pq.empty()) {
        vector<int> cur = pq.top();
        pq.pop();
        
        // - cur[1] represents the min cost to reach cur[0]
        // - there cannot be a cost that is smaller than current cost
        // later in the loop
        // - you can technically check if c[0] == dst and return here
        for (vector<int>& neighbor: adj[cur[0]]) {
            if (cost[neighbor[0]] > cur[1] + neighbor[1]) {
                cost[neighbor[0]] = cur[1] + neighbor[1];
                pq.push({neighbor[0], cost[neighbor[0]]});
            }
        }
    }
    return cost[dst];
}

void bellmanFord(int V, int src, vector<vector<int>>& edges) {
    vector<int> cost(V, INT_MAX);
    cost[src] = 0;

    for (int i = 0; i < V - 1; ++i) {
        for (vector<int>& edge: edges) {
            int source = edge[0];
            int destination = edge[1];
            if (cost[source] == INT_MAX) continue;
            // to check to see what happens after each iteration of i
            // we need to create a temporary vector if not it will not strictly
            // show you values after ith iteration; could show i+ th iteration
            int new_cost = edge[2] + cost[source];
            if (cost[destination] > new_cost) {
                cost[destination] = new_cost;
            }
        }
    }
    // you can do an extra loop here to check for negative cycle
}