Dijkstra’s Shortest Path Algorithm

The main problem is the same as the previous one, from the starting node to any other node, find the smallest distances. In this problem, the main difference is that the graph is represented using the adjacency matrix. (Cost matrix and adjacency matrix is similar for this purpose).

For the adjacency list representation, the time complexity is O(V^2) where V is the number of nodes in the graph G(V, E)

Input and Output

Input:
The adjacency matrix:

Output:
0 to 1, Using: 0, Cost: 3
0 to 2, Using: 1, Cost: 5
0 to 3, Using: 1, Cost: 4
0 to 4, Using: 3, Cost: 6
0 to 5, Using: 2, Cost: 7
0 to 6, Using: 4, Cost: 7

Algorithm

dijkstraShortestPath(n, dist, next, start)

Input − Total number of nodes n, distance list for each vertex, next list to store which node comes next, and the seed or start vertex.

Output − The shortest paths from start to all other vertices.

Begin
   create a status list to hold the current status of the selected node
   for all vertices u in V do
      status[u] := unconsidered
      dist[u] := distance from source using cost matrix
      next[u] := start
   done

   status[start] := considered, dist[start] := 0 and next[start] := φ
   while take unconsidered vertex u as distance is minimum do
      status[u] := considered
      for all vertex v in V do
         if status[v] = unconsidered then
            if dist[v] > dist[u] + cost[u,v] then
               dist[v] := dist[u] + cost[u,v]
               next[v] := u
      done
   done
End

Example

#include<iostream>
#define V 7
#define INF 999
using namespace std;

// Cost matrix of the graph
int costMat[V][V] = {
   {0, 3, 6, INF, INF, INF, INF},
   {3, 0, 2, 1, INF, INF, INF},
   {6, 2, 0, 1, 4, 2, INF},
   {INF, 1, 1, 0, 2, INF, 4},
   {INF, INF, 4, 2, 0, 2, 1},
   {INF, INF, 2, INF, 2, 0, 1},
   {INF, INF, INF, 4, 1, 1, 0}
};

int minimum(int *status, int *dis, int n) {
   int i, min, index;
   min = INF;

   for(i = 0; i<n; i++)
      if(dis[i] < min && status[i] == 1) {
         min = dis[i];
         index = i;
      }

   if(status[index] == 1)
      return index; //minimum unconsidered vertex distance
   else
      return -1;    //when all vertices considered
}

void dijkstra(int n, int *dist,int *next, int s) {
   int status[V];
   int u, v;

   //initialization
   for(u = 0; u<n; u++) {
      status[u] = 1;               //unconsidered vertex
      dist[u] = costMat[u][s];     //distance from source
      next[u] = s;
   }

   //for source vertex
   status[s] = 2; dist[s] = 0; next[s] = -1; //-1 for starting vertex

   while((u = minimum(status, dist, n)) > -1) {
      status[u] = 2;//now considered
      for(v = 0; v<n; v++)
         if(status[v] == 1)
            if(dist[v] > dist[u] + costMat[u][v]) {
               dist[v] = dist[u] + costMat[u][v];   //update distance
               next[v] = u;
            }
   }
}

main() {
   int dis[V], next[V], i, start = 0;
   dijkstra(V, dis, next, start);

   for(i = 0; i<V; i++)
      if(i != start)
         cout << start << " to " << i <<", Using: " << next[i] << ",
   Cost: " << dis[i] << endl;
}

Output

0 to 1, Using: 0, Cost: 3
0 to 2, Using: 1, Cost: 5
0 to 3, Using: 1, Cost: 4
0 to 4, Using: 3, Cost: 6
0 to 5, Using: 2, Cost: 7
0 to 6, Using: 4, Cost: 7