GeeksforGeeks App
Open App
Browser
Continue

# Dijkstra’s Shortest Path Algorithm using priority_queue of STL

Given a graph and a source vertex in graph, find shortest paths from source to all vertices in the given graph.

```Input : Source = 0
Output :
Vertex   Distance from Source
0                0
1                4
2                12
3                19
4                21
5                11
6                9
7                8
8                14```

We have discussed Dijkstra’s shortest Path implementations.

The second implementation is time complexity wise better but is really complex as we have implemented our own priority queue. The Third implementation is simpler as it uses STL. The issue with third implementation is, it uses set which in turn uses Self-Balancing Binary Search Trees. For Dijkstra’s algorithm, it is always recommended to use heap (or priority queue) as the required operations (extract minimum and decrease key) match with speciality of heap (or priority queue). However, the problem is, priority_queue doesn’t support decrease key. To resolve this problem, do not update a key, but insert one more copy of it. So we allow multiple instances of same vertex in priority queue. This approach doesn’t require decrease key operation and has below important properties.

• Whenever distance of a vertex is reduced, we add one more instance of vertex in priority_queue. Even if there are multiple instances, we only consider the instance with minimum distance and ignore other instances.
• The time complexity remains O(ELogV)) as there will be at most O(E) vertices in priority queue and O(Log E) is same as O(Log V)

Below is algorithm based on above idea.

```1) Initialize distances of all vertices as infinite.

2) Create an empty priority_queue pq.  Every item
of pq is a pair (weight, vertex). Weight (or
distance) is used  as first item  of pair
as first item is by default used to compare
two pairs

3) Insert source vertex into pq and make its
distance as 0.

4) While either pq doesn't become empty
a) Extract minimum distance vertex from pq.
Let the extracted vertex be u.
b) Loop through all adjacent of u and do
following for every vertex v.

// If there is a shorter path to v
// through u.
If dist[v] > dist[u] + weight(u, v)

(i) Update distance of v, i.e., do
dist[v] = dist[u] + weight(u, v)
(ii) Insert v into the pq (Even if v is

5) Print distance array dist[] to print all shortest
paths. ```

Below is C++ implementation of above idea.

## CPP

 `// Program to find Dijkstra's shortest path using``// priority_queue in STL``#include ``using` `namespace` `std;``#define INF 0x3f3f3f3f` `// iPair ==> Integer Pair``typedef` `pair<``int``, ``int``> iPair;` `// This class represents a directed graph using``// adjacency list representation``class` `Graph {``    ``int` `V; ``// No. of vertices` `    ``// In a weighted graph, we need to store vertex``    ``// and weight pair for every edge``    ``list >* adj;` `public``:``    ``Graph(``int` `V); ``// Constructor` `    ``// function to add an edge to graph``    ``void` `addEdge(``int` `u, ``int` `v, ``int` `w);` `    ``// prints shortest path from s``    ``void` `shortestPath(``int` `s);``};` `// Allocates memory for adjacency list``Graph::Graph(``int` `V)``{``    ``this``->V = V;``    ``adj = ``new` `list[V];``}` `void` `Graph::addEdge(``int` `u, ``int` `v, ``int` `w)``{``    ``adj[u].push_back(make_pair(v, w));``    ``adj[v].push_back(make_pair(u, w));``}` `// Prints shortest paths from src to all other vertices``void` `Graph::shortestPath(``int` `src)``{``    ``// Create a priority queue to store vertices that``    ``// are being preprocessed. This is weird syntax in C++.``    ``// Refer below link for details of this syntax``    ``// https://www.geeksforgeeks.org/implement-min-heap-using-stl/``    ``priority_queue, greater >``        ``pq;` `    ``// Create a vector for distances and initialize all``    ``// distances as infinite (INF)``    ``vector<``int``> dist(V, INF);` `    ``// Insert source itself in priority queue and initialize``    ``// its distance as 0.``    ``pq.push(make_pair(0, src));``    ``dist[src] = 0;` `    ``/* Looping till priority queue becomes empty (or all``    ``distances are not finalized) */``    ``while` `(!pq.empty()) {``        ``// The first vertex in pair is the minimum distance``        ``// vertex, extract it from priority queue.``        ``// vertex label is stored in second of pair (it``        ``// has to be done this way to keep the vertices``        ``// sorted distance (distance must be first item``        ``// in pair)``        ``int` `u = pq.top().second;``        ``pq.pop();` `        ``// 'i' is used to get all adjacent vertices of a``        ``// vertex``        ``list >::iterator i;``        ``for` `(i = adj[u].begin(); i != adj[u].end(); ++i) {``            ``// Get vertex label and weight of current``            ``// adjacent of u.``            ``int` `v = (*i).first;``            ``int` `weight = (*i).second;` `            ``// If there is shorted path to v through u.``            ``if` `(dist[v] > dist[u] + weight) {``                ``// Updating distance of v``                ``dist[v] = dist[u] + weight;``                ``pq.push(make_pair(dist[v], v));``            ``}``        ``}``    ``}` `    ``// Print shortest distances stored in dist[]``    ``printf``(``"Vertex Distance from Source\n"``);``    ``for` `(``int` `i = 0; i < V; ++i)``        ``printf``(``"%d \t\t %d\n"``, i, dist[i]);``}` `// Driver program to test methods of graph class``int` `main()``{``    ``// create the graph given in above figure``    ``int` `V = 9;``    ``Graph g(V);` `    ``// making above shown graph``    ``g.addEdge(0, 1, 4);``    ``g.addEdge(0, 7, 8);``    ``g.addEdge(1, 2, 8);``    ``g.addEdge(1, 7, 11);``    ``g.addEdge(2, 3, 7);``    ``g.addEdge(2, 8, 2);``    ``g.addEdge(2, 5, 4);``    ``g.addEdge(3, 4, 9);``    ``g.addEdge(3, 5, 14);``    ``g.addEdge(4, 5, 10);``    ``g.addEdge(5, 6, 2);``    ``g.addEdge(6, 7, 1);``    ``g.addEdge(6, 8, 6);``    ``g.addEdge(7, 8, 7);` `    ``g.shortestPath(0);` `    ``return` `0;``}`

Output

```Vertex Distance from Source
0          0
1          4
2          12
3          19
4          21
5          11
6          9
7          8
8          14```

Time complexity : O(E log V)

Space Complexuty:O(V2) , here V is number of Vertices.

A Quicker Implementation using vector of pairs representation of weighted graph

## CPP

 `// Program to find Dijkstra's shortest path using``// priority_queue in STL``#include ``using` `namespace` `std;``#define INF 0x3f3f3f3f` `// iPair ==> Integer Pair``typedef` `pair<``int``, ``int``> iPair;` `// To add an edge``void` `addEdge(vector > adj[], ``int` `u, ``int` `v,``             ``int` `wt)``{``    ``adj[u].push_back(make_pair(v, wt));``    ``adj[v].push_back(make_pair(u, wt));``}` `// Prints shortest paths from src to all other vertices``void` `shortestPath(vector > adj[], ``int` `V,``                  ``int` `src)``{``    ``// Create a priority queue to store vertices that``    ``// are being preprocessed. This is weird syntax in C++.``    ``// Refer below link for details of this syntax``    ``// https://www.geeksforgeeks.org/implement-min-heap-using-stl/``    ``priority_queue, greater >``        ``pq;` `    ``// Create a vector for distances and initialize all``    ``// distances as infinite (INF)``    ``vector<``int``> dist(V, INF);` `    ``// Insert source itself in priority queue and initialize``    ``// its distance as 0.``    ``pq.push(make_pair(0, src));``    ``dist[src] = 0;` `    ``/* Looping till priority queue becomes empty (or all``    ``distances are not finalized) */``    ``while` `(!pq.empty()) {``        ``// The first vertex in pair is the minimum distance``        ``// vertex, extract it from priority queue.``        ``// vertex label is stored in second of pair (it``        ``// has to be done this way to keep the vertices``        ``// sorted distance (distance must be first item``        ``// in pair)``        ``int` `u = pq.top().second;``        ``pq.pop();` `        ``// Get all adjacent of u.``        ``for` `(``auto` `x : adj[u]) {``            ``// Get vertex label and weight of current``            ``// adjacent of u.``            ``int` `v = x.first;``            ``int` `weight = x.second;` `            ``// If there is shorted path to v through u.``            ``if` `(dist[v] > dist[u] + weight) {``                ``// Updating distance of v``                ``dist[v] = dist[u] + weight;``                ``pq.push(make_pair(dist[v], v));``            ``}``        ``}``    ``}` `    ``// Print shortest distances stored in dist[]``    ``printf``(``"Vertex Distance from Source\n"``);``    ``for` `(``int` `i = 0; i < V; ++i)``        ``printf``(``"%d \t\t %d\n"``, i, dist[i]);``}` `// Driver program to test methods of graph class``int` `main()``{``    ``int` `V = 9;``    ``vector adj[V];` `    ``// making above shown graph``    ``addEdge(adj, 0, 1, 4);``    ``addEdge(adj, 0, 7, 8);``    ``addEdge(adj, 1, 2, 8);``    ``addEdge(adj, 1, 7, 11);``    ``addEdge(adj, 2, 3, 7);``    ``addEdge(adj, 2, 8, 2);``    ``addEdge(adj, 2, 5, 4);``    ``addEdge(adj, 3, 4, 9);``    ``addEdge(adj, 3, 5, 14);``    ``addEdge(adj, 4, 5, 10);``    ``addEdge(adj, 5, 6, 2);``    ``addEdge(adj, 6, 7, 1);``    ``addEdge(adj, 6, 8, 6);``    ``addEdge(adj, 7, 8, 7);` `    ``shortestPath(adj, V, 0);` `    ``return` `0;``}`

Output

```Vertex Distance from Source
0          0
1          4
2          12
3          19
4          21
5          11
6          9
7          8
8          14```

The time complexity of Dijkstra’s algorithm using a priority queue implemented with a binary heap is O(Elog(V)), where E is the number of edges and V is the number of vertices in the graph.

The space complexity of this implementation is O(V+E), where V is the number of vertices and E is the number of edges.

## Java

 `import` `java.util.ArrayList;``import` `java.util.Arrays;``import` `java.util.HashMap;``import` `java.util.PriorityQueue;` `public` `class` `DijkstraAlgoForShortestDistance {` `    ``static` `class` `Node ``implements` `Comparable {``        ``int` `v;``        ``int` `distance;` `        ``public` `Node(``int` `v, ``int` `distance)``        ``{``            ``this``.v = v;``            ``this``.distance = distance;``        ``}` `        ``@Override` `public` `int` `compareTo(Node n)``        ``{``            ``if` `(``this``.distance <= n.distance) {``                ``return` `-``1``;``            ``}``            ``else` `{``                ``return` `1``;``            ``}``        ``}``    ``}` `    ``static` `int``[] dijkstra(``        ``int` `V,``        ``ArrayList > > adj,``        ``int` `S)``    ``{``        ``boolean``[] visited = ``new` `boolean``[V];``        ``HashMap map = ``new` `HashMap<>();``        ``PriorityQueue q = ``new` `PriorityQueue<>();` `        ``map.put(S, ``new` `Node(S, ``0``));``        ``q.add(``new` `Node(S, ``0``));` `        ``while` `(!q.isEmpty()) {``            ``Node n = q.poll();``            ``int` `v = n.v;``            ``int` `distance = n.distance;``            ``visited[v] = ``true``;` `            ``ArrayList > adjList``                ``= adj.get(v);``            ``for` `(ArrayList adjLink : adjList) {` `                ``if` `(visited[adjLink.get(``0``)] == ``false``) {``                    ``if` `(!map.containsKey(adjLink.get(``0``))) {``                        ``map.put(``                            ``adjLink.get(``0``),``                            ``new` `Node(v,``                                     ``distance``                                         ``+ adjLink.get(``1``)));``                    ``}``                    ``else` `{``                        ``Node sn = map.get(adjLink.get(``0``));``                        ``if` `(distance + adjLink.get(``1``)``                            ``< sn.distance) {``                            ``sn.v = v;``                            ``sn.distance``                                ``= distance + adjLink.get(``1``);``                        ``}``                    ``}``                    ``q.add(``new` `Node(adjLink.get(``0``),``                                   ``distance``                                       ``+ adjLink.get(``1``)));``                ``}``            ``}``        ``}` `        ``int``[] result = ``new` `int``[V];``        ``for` `(``int` `i = ``0``; i < V; i++) {``            ``result[i] = map.get(i).distance;``        ``}` `        ``return` `result;``    ``}` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``ArrayList > > adj``            ``= ``new` `ArrayList<>();``        ``HashMap > >``            ``map = ``new` `HashMap<>();` `        ``int` `V = ``6``;``        ``int` `E = ``5``;``        ``int``[] u = { ``0``, ``0``, ``1``, ``2``, ``4` `};``        ``int``[] v = { ``3``, ``5``, ``4``, ``5``, ``5` `};``        ``int``[] w = { ``9``, ``4``, ``4``, ``10``, ``3` `};` `        ``for` `(``int` `i = ``0``; i < E; i++) {``            ``ArrayList edge = ``new` `ArrayList<>();``            ``edge.add(v[i]);``            ``edge.add(w[i]);` `            ``ArrayList > adjList;``            ``if` `(!map.containsKey(u[i])) {``                ``adjList = ``new` `ArrayList<>();``            ``}``            ``else` `{``                ``adjList = map.get(u[i]);``            ``}``            ``adjList.add(edge);``            ``map.put(u[i], adjList);` `            ``ArrayList edge2 = ``new` `ArrayList<>();``            ``edge2.add(u[i]);``            ``edge2.add(w[i]);` `            ``ArrayList > adjList2;``            ``if` `(!map.containsKey(v[i])) {``                ``adjList2 = ``new` `ArrayList<>();``            ``}``            ``else` `{``                ``adjList2 = map.get(v[i]);``            ``}``            ``adjList2.add(edge2);``            ``map.put(v[i], adjList2);``        ``}` `        ``for` `(``int` `i = ``0``; i < V; i++) {``            ``if` `(map.containsKey(i)) {``                ``adj.add(map.get(i));``            ``}``            ``else` `{``                ``adj.add(``null``);``            ``}``        ``}``        ``int` `S = ``1``;` `        ``// Input sample``        ``//[0 [[3, 9], [5, 4]],``        ``// 1 [[4, 4]],``        ``// 2 [[5, 10]],``        ``// 3 [[0, 9]],``        ``// 4 [[1, 4], [5, 3]],``        ``// 5 [[0, 4], [2, 10], [4, 3]]``        ``//]``        ``int``[] result``            ``= DijkstraAlgoForShortestDistance.dijkstra(``                ``V, adj, S);``        ``System.out.println(Arrays.toString(result));``    ``}``}`

## Python3

 `#Python``#import modules``import` `heapq` `#Define a class Node to store the values``class` `Node:``    ``def` `__init__(``self``, v, distance):``        ``self``.v ``=` `v``        ``self``.distance ``=` `distance``    ``#define a comparator method to compare distance of two nodes``    ``def` `__lt__(``self``, other):``        ``return` `self``.distance < other.distance` `#function to implement Dijkstra Algorithm to find shortest distance``def` `dijkstra(V, adj, S):``    ``#initialize a visited list and map``    ``visited ``=` `[``False``] ``*` `V``    ``map` `=` `{}``    ``#initialize a priority queue``    ``q ``=` `[]``    ``#insert source node in map``    ``map``[S] ``=` `Node(S, ``0``)``    ``#add source node to priority queue``    ``heapq.heappush(q, Node(S, ``0``))``    ``#while the priority queue is not empty``    ``while` `q:``        ``#pop the node with minimum distance from priority queue``        ``n ``=` `heapq.heappop(q)``        ``#get the vertex and distance``        ``v ``=` `n.v``        ``distance ``=` `n.distance``        ``#mark the vertex as visited``        ``visited[v] ``=` `True``        ``#get the adjacent list of the vertex``        ``adjList ``=` `adj[v]``        ``#for every adjacent node of the vertex``        ``for` `edge ``in` `adjList:``            ``#if the node is not yet visited``            ``if` `visited[edge[``0``]] ``=``=` `False``:``                ``#if the node is not present in map``                ``if` `edge[``0``] ``not` `in` `map``:``                    ``#put the node in map``                    ``map``[edge[``0``]] ``=` `Node(v, distance ``+` `edge[``1``])``                ``else``:``                    ``#get the node from map``                    ``sn ``=` `map``[edge[``0``]]``                    ``#check if the new distance is less than the current distance of the node``                    ``if` `distance ``+` `edge[``1``] < sn.distance:``                        ``#update the node's distance``                        ``sn.v ``=` `v``                        ``sn.distance ``=` `distance ``+` `edge[``1``]``                ``#push the node to priority queue``                ``heapq.heappush(q, Node(edge[``0``], distance ``+` `edge[``1``]))``    ``#initialize a result list``    ``result ``=` `[``0``] ``*` `V``    ``#for every key in map``    ``for` `key ``in` `map``.keys():``        ``#add the distance of the node to the result``        ``result[key] ``=` `map``[key].distance``    ``#return the result list``    ``return` `result` `#main function``if` `__name__ ``=``=` `'__main__'``:``    ``#initialize adjacency list and map``    ``adj ``=` `[]``    ``map` `=` `{}``    ``#initialize number of vertices and edges``    ``V ``=` `6``    ``E ``=` `5``    ``#define u, v and w``    ``u ``=` `[``0``, ``0``, ``1``, ``2``, ``4``]``    ``v ``=` `[``3``, ``5``, ``4``, ``5``, ``5``]``    ``w ``=` `[``9``, ``4``, ``4``, ``10``, ``3``]` `    ``#for every edge``    ``for` `i ``in` `range``(E):``        ``#create an edge list``        ``edge ``=` `[v[i], w[i]]``        ``#if the u[i] is not present in map``        ``if` `u[i] ``not` `in` `map``:``            ``#create a new adjacency list``            ``adjList ``=` `[]``        ``else``:``            ``#get the existing adjacency list``            ``adjList ``=` `map``[u[i]]``        ``#add the edge to the adjacency list``        ``adjList.append(edge)``        ``#put the adjacency list in map``        ``map``[u[i]] ``=` `adjList``        ``#create another edge list``        ``edge2 ``=` `[u[i], w[i]]``        ``#if the v[i] is not present in map``        ``if` `v[i] ``not` `in` `map``:``            ``#create a new adjacency list``            ``adjList2 ``=` `[]``        ``else``:``            ``#get the existing adjacency list``            ``adjList2 ``=` `map``[v[i]]``        ``#add the edge to the adjacency list``        ``adjList2.append(edge2)``        ``#put the adjacency list in map``        ``map``[v[i]] ``=` `adjList2` `    ``#for every vertex``    ``for` `i ``in` `range``(V):``        ``#if the vertex is present in map``        ``if` `i ``in` `map``:``            ``#add the adjacency list to the main adjacency list``            ``adj.append(``map``[i])``        ``else``:``            ``#add null to the main adjacency list``            ``adj.append(``None``)``    ``#define source node``    ``S ``=` `1``    ``#call the dijkstra function``    ``result ``=` `dijkstra(V, adj, S)``    ``#print the result``    ``print``(result)`

Output

`[11, 0, 17, 20, 4, 7]`

Time Complexity: O(ElogV)
The time complexity is O(ElogV) where E is the number of edges and V is the number of vertices. This is because, for each vertex, we need to traverse all its adjacent vertices and update their distances, which takes O(E) time. Also, we use a Priority Queue which takes O(logV) time for each insertion and deletion.

Space Complexity: O(V)
The space complexity is O(V) as we need to maintain a visited array of size V, a map of size V and a Priority Queue of size V.