Implementing Dijkstra's Algorithm

class Solution
{
	public:
	//Function to find the shortest distance of all the vertices
    //from the source vertex S.
    vector <int> dijkstra(int V, vector<vector<int>> adj[], int S)
    {
        
        //using priority Queue:
        
        // priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
        // vector<int> dist(V, 1e9);
        // dist[S] = 0;
        // pq.push({0, S});
        // while(!pq.empty()){
        //     int dis = pq.top().first;
        //     int node = pq.top().second;
        //     pq.pop();
        //     for(auto it: adj[node]){
        //         int edgeWeight = it[1];
        //         int adjNode = it[0];
                
        //         if(dis + edgeWeight < dist[adjNode]){
        //             dist[adjNode] = dis + edgeWeight;
        //             pq.push({dist[adjNode], adjNode});
        //         }
        //     }
        // }
        // return dist;
        
        //Using Set
        set<pair<int, int>> st;
        vector<int> dist(V, 1e9);
        st.insert({0, S});
        dist[S] = 0;
        while(!st.empty()){
            auto it = *(st.begin());
            int dis = it.first;
            int node = it.second;
            st.erase(it);
            
            for(auto it: adj[node]){
                int edgeWeight = it[1];
                int adjNode = it[0];
                if(dis + edgeWeight < dist[adjNode]){
                    //check if that node is visited or not i.e the dist is 1e9 or not 
                    //if dist is not 1e9 and we have better dist than previous then erase that node
                    //from set and add new node with better dist than previous it can save time
                    if(dist[adjNode] != 1e9) st.erase({dist[adjNode], adjNode});
                    dist[adjNode] = dis + edgeWeight;
                    st.insert({dist[adjNode], adjNode});
                }
            }
        }
        return dist;
        
    }
};