Practical 2

Implement the Dijkstra Shortest Path Algorithm

Introduction
For a given source vertex (node) in the graph, the algorithm finds the path with lowest cost (i.e. the
shortest path) between that vertex and every other vertex. It can also be used for finding costs of
shortest paths from a single vertex to a single destination vertex by stopping the algorithm once the
shortest path to the destination vertex has been determined.
For example, if the vertices of the graph represent cities and edge path costs represent driving
distances between pairs of cities connected by a direct road, Dijkstra's algorithm can be used to find
the shortest route between one city and all other cities. As a result, the shortest path first is widely
used in network routing protocols, most notably OSPF (Open Shortest Path First).

Technical Detail
Algorithm
Dijkstra's algorithm will assign some initial distance values and will try to improve them
step by step.
1. Assign to every node a tentative distance value: set it to zero for our initial node and
to infinity for all other nodes.
2. Mark all nodes except the initial node as unvisited. Set the initial node as current.
Create a set of the unvisited nodes called the unvisited set consisting of all the nodes
except the initial node.
3. For the current node, consider all of its unvisited neighbors and calculate their
tentative distances. For example, if the current node A is marked with a distance of
6, and the edge connecting it with a neighbor B has length 2, then the distance to B
(through A) will be 6+2=8. If this distance is less than the previously recorded
distance, then overwrite that distance. Even though a neighbor has been examined,
it is not marked as visited at this time, and it remains in the unvisited set.
4. When we are done considering all of the neighbors of the current node, mark the
current node as visited and remove it from the unvisited set. A visited node will
never be checked again; its distance recorded now is final and minimal.
5. The next current node will be the node marked with the lowest (tentative) distance
in the unvisited set.
6. If the unvisited set is empty, then stop. The algorithm has finished. Otherwise, set the
unvisited node marked with the smallest tentative distance as the next "current
node" and go back to step 3.

Programming Language
This program has been developed using core java.

Here program is having following graph

arrangement
Here

V0 = Redville
V1 = Blueville
V2 = Organgeville
V3 = Greenville
V4 = Purpleville

Code
import java.util.PriorityQueue;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
class Vertex implements Comparable<Vertex>
{
public final String name;
public Edge[] adjacencies;
public double minDistance = Double.POSITIVE_INFINITY;
public Vertex previous;
public Vertex(String argName) { name = argName; }
public String toString() { return name; }
public int compareTo(Vertex other)
{
return Double.compare(minDistance, other.minDistance);
}
}
class Edge
{

public final Vertex target;

public final double weight;
public Edge(Vertex argTarget, double argWeight)
{ target = argTarget; weight = argWeight; }
}
public class Dijkstra
{
public static void computePaths(Vertex source)
{
source.minDistance = 0.;
PriorityQueue<Vertex> vertexQueue = new PriorityQueue<Vertex>();
vertexQueue.add(source);
while (!vertexQueue.isEmpty()) {
Vertex u = vertexQueue.poll();
// Visit each edge exiting u
for (Edge e : u.adjacencies)
{
Vertex v = e.target;
double weight = e.weight;
double distanceThroughU = u.minDistance + weight;
if (distanceThroughU < v.minDistance) {
vertexQueue.remove(v);
v.minDistance = distanceThroughU ;
v.previous = u;
vertexQueue.add(v);
}
}
}
}
public static List<Vertex> getShortestPathTo(Vertex target)
{
List<Vertex> path = new ArrayList<Vertex>();
for (Vertex vertex = target; vertex != null; vertex = vertex.previous)
path.add(vertex);
Collections.reverse(path);
return path;
}
public static void main(String[] args)
{
Vertex v0 = new Vertex("Redville");
Vertex v1 = new Vertex("Blueville");
Vertex v2 = new Vertex("Greenville");

Vertex v3 = new Vertex("Orangeville");

Vertex v4 = new Vertex("Purpleville");
v0.adjacencies = new Edge[]{ new Edge(v1, 5), new Edge(v2, 10), new Edge(v3, 8) };
v1.adjacencies = new Edge[]{ new Edge(v0, 5), new Edge(v2, 3), new Edge(v4, 7) };
v2.adjacencies = new Edge[]{ new Edge(v0, 10), new Edge(v1, 3) };
v3.adjacencies = new Edge[]{ new Edge(v0, 8), new Edge(v4, 2) };
v4.adjacencies = new Edge[]{ new Edge(v1, 7), new Edge(v3, 2) };
Vertex[] vertices = { v0, v1, v2, v3, v4 };
computePaths(v0);
for (Vertex v : vertices)
{
System.out.println("Distance to " + v + ": " + v.minDistance);
List<Vertex> path = getShortestPathTo(v);
System.out.println("Shortest Path: " + path);
}
}
}

Output

Figure shows output of Dijsktras algorithm. Here the shortest path from Redville to Purpleville is
Redville -> Orangeville -> Purpleville.