Untitled

class Solution {
public:
    int getMinCost(int gNodes, vector<int>& gFrom, vector<int>& gTo, 
                   vector<int>& gWeight, vector<int>& arr, int A, int B) {
                       
        
                       
        vector<vector<pair<int, int>>> graph(gNodes + 1);
        for (int i = 0; i < gFrom.size(); i++) {
            int u = gFrom[i];
            int v = gTo[i];
            int w = gWeight[i];
            graph[u].push_back({v, w});
            graph[v].push_back({u, w});
        }
        
        vector<long long> min_cost(gNodes + 1, 0);
        for(int i=0;i<gNodes+1;i++){
            min_cost[i]=LLONG_MAX;
        }
        
        min_cost[A] = 0;
        
        priority_queue<pair<long long, int>, 
                            vector<pair<long long, int>>, 
                            greater<pair<long long, int>>> pq;
                            
        long long minVal = arr[A-1];
        pq.push({0, A});
        
        while (!pq.empty()) {
            long long current_cost = pq.top().first;
            int current_city = pq.top().second;
            cout<<"current_city"<<current_city<<endl;
            pq.pop();
            
            if(arr[current_city-1] > minVal){
                arr[current_city-1] = minVal;
            } else{
                minVal = arr[current_city-1];
            }
            
            if (current_city == B) {
                return current_cost;
            }
            
            if (current_cost > min_cost[current_city]) {
                continue;
            }
            
            for (auto& [neighbor, weight] : graph[current_city]) {
                cout<<current_city<<" "<<neighbor<<" "<<min_cost[current_city];
                cout<<endl;
                long long travel_cost = weight * arr[current_city-1];
                cout<<weight<<" "<<arr[current_city-1]<<" "<<travel_cost<<endl;
                long long total_cost = min_cost[current_city] + travel_cost;
                
                if (total_cost < min_cost[neighbor]) {
                    cout<<total_cost<<endl;
                    min_cost[neighbor] = total_cost;
                    pq.push({total_cost, neighbor});
                }
            }
        }
        
        return min_cost[B] == LLONG_MAX ? -1 : min_cost[B];
    }
};