# Dijkstra’s Algorithm – Shortest distance

Problem Statement: Given a weighted, undirected, and connected graph of V vertices and E edges, Find the shortest distance of all the vertex’s from the source vertex S.

Note: The Graph doesn’t contain any negative weight cycle.

Examples:

```Example 1:

Input:

Output: [0,2,4,1,5]

Explanation: Given the following undirected graph, the shortest distance from node 1(source node) to itself is definitely zero. For nodes 2 and 4, the minimum distance is 2 and 1 respectively.
For node 3, the possible paths are 1->2->3(cost = 6) or 1->4->3(cost = 4) or 1->2->5->3(cost = 8). The minimum of these three paths would be our answer which is 4.
For node 5, the possible paths are 1->2->5(cost = 7) or 1->4->3->5(cost = 5) or 1->4->3->2->5(cost = 13). The minimum of these three paths would be our answer which is 5.
```
```Example 2:

Input:

Output: [0,3,4,5]

Explanation: Given the following undirected graph, the shortest distance from node 0(source node) to itself is definitely zero. For node 1 to shortest distance would be 3(only way to reach node 1).
For node 2 we have paths 0->1->2(cost = 4) or 0->1->3->2(cost = 8). The minimum of these three paths would be our answer which is 4. For node 3 we have paths 0->1->3(cost =7) or 0->1->2->3(cost = 5)
```

### Solution:

DisclaimerDon’t jump directly to the solution, try it out yourself first.

Intuition: The above problem seems familiar to finding the shortest distance in the case of unit edge weights for undirected graphs. Hence, our first guess could be a BFS kind of approach. The only thing that we need to take care of is that of all the paths possible between a pair of nodes, we need to store the minimum distance between them. That is, say we have a node that has been reached by two paths, one with a cost of 5 and another with a cost of 10. It is obvious that the path with a cost of 5 would continue to give optimal distance for its adjacent node as opposed to the path with a cost of 10.

Approach:

#### We can implement the algorithm using the following steps:

1. We would be using a min-heap and a distance array of size N initialized with infinity (indicating that at present none of the nodes are reachable from the source node) and initialize the distance to source node as 0.
2. We push the source node to the queue.
3. For every node at the top of the queue we pop that element out and look out for its adjacent nodes. If the current reachable distance is better than the previous distance indicated by the distance array, we update the distance and push it in the queue.
4. A node with a lower distance would be at the top of the priority queue as opposed to a node with a higher distance. By following the steps 3, until our queue becomes empty, we would get the minimum distance from the source node to all other nodes. Here’s a quick demonstration of the same.

## C++ Code

``````#include<bits/stdc++.h>
using namespace std;
int main(){
int n=5,m=6,source=1;
vector<pair<int,int> > g[n+1]; 	// assuming 1 based indexing of graph
// Constructing the graph
g[1].push_back({2,2});
g[1].push_back({4,1});
g[2].push_back({1,2});
g[2].push_back({5,5});
g[2].push_back({3,4});
g[3].push_back({2,4});
g[3].push_back({4,3});
g[3].push_back({5,1});
g[4].push_back({1,1});
g[4].push_back({3,3});
g[5].push_back({2,5});
g[5].push_back({3,1});
// Dijkstra's algorithm begins from here
priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int>>> pq;
vector<int> distTo(n+1,INT_MAX);//1-indexed array for calculating shortest paths
distTo[source] = 0;
pq.push(make_pair(0,source));	// (dist,source)
while( !pq.empty() ){
int dist = pq.top().first;
int prev = pq.top().second;
pq.pop();
vector<pair<int,int> >::iterator it;
for( it = g[prev].begin() ; it != g[prev].end() ; it++){
int next = it->first;
int nextDist = it->second;
if( distTo[next] > distTo[prev] + nextDist){
distTo[next] = distTo[prev] + nextDist;
pq.push(make_pair(distTo[next], next));
}
}
}
cout << "The distances from source " << source << " are : \n";
for(int i = 1 ; i<=n ; i++)	cout << distTo[i] << " ";
cout << "\n";
return 0;
}
``````

Output:

The distances from source 1 are :
0 2 4 1 5

Time Complexity: O((N+E)*logN). Going through N nodes and E edges and log N for priority queue

Space Complexity: O(N). Distance array and priority queue

## Java Code

``````import java.util.*;

class Node implements Comparator<Node>
{
private int v;
private int weight;

Node(int _v, int _w) { v = _v; weight = _w; }

Node() {}

int getV() { return v; }
int getWeight() { return weight; }

@Override
public int compare(Node node1, Node node2)
{
if (node1.weight < node2.weight)
return -1;
if (node1.weight > node2.weight)
return 1;
return 0;
}
}

class Main
{
void shortestPath(int s, ArrayList<ArrayList<Node>> adj, int N)
{
int dist[] = new int[N];

for(int i = 0;i<N;i++) dist[i] = 100000000;
dist[s] = 0;

PriorityQueue<Node> pq = new PriorityQueue<Node>(N, new Node());

while(pq.size() > 0) {
Node node = pq.poll();

if(dist[node.getV()] + it.getWeight() < dist[it.getV()]) {
dist[it.getV()] = dist[node.getV()] + it.getWeight();
}
}
}
System.out.println("The distances from source "+s+" are : ");
for (int i = 0; i < N; i++)
{
System.out.print( dist[i] + " ");
}
}
public static void main(String args[])
{
int n = 5;
ArrayList<ArrayList<Node> > adj = new ArrayList<ArrayList<Node> >();

for (int i = 0; i < n; i++)

Main obj = new Main();

}
}``````

Output:

The distances from source 0 are :
0 2 4 1 5

Time Complexity: O((N+E)*logN). Going through N nodes and E edges and log N for priority queue

Space Complexity: O(N). Distance array and priority queue