Added some comments in the code.

Author: navjindervirdee

Bidirectional Dijkstra/FriendSuggestion$PriorityQueue.class

@@ -5,37 +5,15 @@
 import java.util.Comparator;
 
 public class FriendSuggestion {
-
- static class Distance{
-int queryId;
-int distance;
-
-public Distance(){
-this.queryId=-1;
-this.distance = Integer.MAX_VALUE;
-}
- }
-
- static class Processed{
-int queryId;
-boolean processed;
-
-public Processed(){
-this.queryId=-1;
-this.processed=false;
-}
- }
-
+
  static class Vertex{
 int vertexNum;
-ArrayList<Integer> adjList;
-ArrayList<Integer> costList;
-//Distance distance;
-//Processed processed;
+ArrayList<Integer> adjList; //adjacent vertices of the vertex.
+ArrayList<Integer> costList; //cost of adjacent edges of the vertex.
 
-int queuePos;
-long dist;
-boolean processed;
+int queuePos; //position of the vertex in the priorityQueue.
+long dist; //distance is stored.
+boolean processed; //is this vertex processed.
 
 public Vertex(){
 }
@@ -44,10 +22,9 @@ public Vertex(int vertexNum){
 this.vertexNum=vertexNum;
 this.adjList = new ArrayList<Integer>();
 this.costList = new ArrayList<Integer>();
-//this.distance = new Distance();
-//this.processed = new Processed();
 }
 
+//initializes the instance variables.
 public void createGraph(Vertex [] graph, Vertex [] reverseGraph, int [] forwPriorityQ, int [] revPriorityQ){
 for(int i=0;i<graph.length;i++){
 graph[i].queuePos=i;
@@ -65,20 +42,11 @@ public void createGraph(Vertex [] graph, Vertex [] reverseGraph, int [] forwPrio
 
  }
 
- /* static class QueueComp implements Comparator<Vertex>{
-public int compare(Vertex vertex1, Vertex vertex2){
-if(vertex1.distance.distance>vertex2.distance.distance){
-return 1;
-}
-
-if(vertex1.distance.distance<vertex2.distance.distance){
-return -1;
-}
-return 0;
-}
- }*/
-
+ 
+ //implemented the priorityQueue by myself.
  static class PriorityQueue{
+
+//swap function maintaining the queuePos variable.
 public void swap(Vertex [] graph, int [] priorityQ, int index1, int index2){
 int temp = priorityQ[index1];
 
@@ -89,10 +57,13 @@ public void swap(Vertex [] graph, int [] priorityQ, int index1, int index2){
 graph[temp].queuePos=index2;
 }
 
+//makes the queue just put the source vertex at position zero ,target vertex has no role.
 public void makeQueue(Vertex [] graph,int [] forwpriorityQ, int source, int target){
 swap(graph, forwpriorityQ,0,source);
 }
 
+
+//extract the min elements i.e the first element.
 public int extractMin(Vertex [] graph, int [] priorityQ, int extractNum){
 int vertex = priorityQ[0];
 int size = priorityQ.length-1-extractNum;
@@ -101,6 +72,8 @@ public int extractMin(Vertex [] graph, int [] priorityQ, int extractNum){
 return vertex;
 }
 
+
+//sift down the larger elements downwards.
 public void siftDown(int index, Vertex [] graph, int [] priorityQ, int size){
 int min = index;
 if(2*index+1<size && graph[priorityQ[index]].dist > graph[priorityQ[2*index+1]].dist){
@@ -115,140 +88,90 @@ public void siftDown(int index, Vertex [] graph, int [] priorityQ, int size){
 }
 }
 
+//changes priority of the vertex.
 public void changePriority(Vertex [] graph, int [] priorityQ, int index){
 if((index-1)/2 > -1 && graph[priorityQ[index]].dist < graph[priorityQ[(index-1)/2]].dist){
 swap(graph,priorityQ,index,(index-1)/2);
 changePriority(graph,priorityQ,(index-1)/2);
 }
 }
  }
- 
+
+
+ //function to relax the edges of the vertex. 
  private static void relaxEdges(Vertex [] graph, int vertex, int [] priorityQ, PriorityQueue queue,int queryId){
 ArrayList<Integer> vertexList = graph[vertex].adjList;
 ArrayList<Integer> costList = graph[vertex].costList;
 graph[vertex].processed = true;
-//graph[vertex].processed.queryId = queryId;
-
-
 
 for(int i=0;i<vertexList.size();i++){
 int temp = vertexList.get(i);
 int cost = costList.get(i);
-/*if(graph[temp].distance.queryId != graph[vertex].distance.queryId || graph[temp].distance.distance>graph[vertex].distance.distance + cost){
-graph[temp].distance.distance = graph[vertex].distance.distance + cost;
-//graph[temp].distance.queryId = queryId ;
-queue.changePriority(graph,priorityQ,graph[temp].queuePos);
-//queue.remove(graph[temp]);
-//queue.add(graph[temp]);
-}*/
+
 if(graph[temp].dist>graph[vertex].dist + cost){
 graph[temp].dist = graph[vertex].dist + cost;
-//graph[temp].distance.queryId = queryId ;
 queue.changePriority(graph,priorityQ,graph[temp].queuePos);
-//queue.remove(graph[temp]);
-//queue.add(graph[temp]);
 }
 }
  }
 
- //static QueueComp comp = new QueueComp();
- //static PriorityQueue<Vertex> forwQ = new PriorityQueue<Vertex>(comp); 
- //static PriorityQueue<Vertex> revQ = new PriorityQueue<Vertex>(comp);
- 
- public static long computeDistance(Vertex [] graph, Vertex [] reverseGraph, int s, int t,int queryId){
-//forwQ.clear();
-//revQ.clear();
-
-//graph[s].distance.distance = 0;
-//graph[s].distance.queryId = queryId;
-
-//reverseGraph[t].distance.distance = 0;
-//reverseGraph[t].distance.queryId = queryId;
-
 
-//forwQ.add(graph[s]);
-//revQ.add(reverseGraph[t]);
+ //bidirectional dijkstra implemented.
+ public static long computeDistance(Vertex [] graph, Vertex [] reverseGraph, int s, int t,int queryId){
+PriorityQueue queue = new PriorityQueue(); //created priotityQueue object.
 
-PriorityQueue queue = new PriorityQueue();
-int [] forwPriorityQ = new int[graph.length];
-int [] revPriorityQ = new int[graph.length];
+int [] forwPriorityQ = new int[graph.length]; //priorityQ for forward search.
+int [] revPriorityQ = new int[graph.length]; //priorityQ for backward search
 
 Vertex vertex = new Vertex();
-vertex.createGraph(graph,reverseGraph,forwPriorityQ,revPriorityQ);
+vertex.createGraph(graph,reverseGraph,forwPriorityQ,revPriorityQ); //reinitializes the graph for each query.
 
-graph[s].dist=0;
-reverseGraph[t].dist=0;
-queue.makeQueue(graph,forwPriorityQ,s,t);
-queue.makeQueue(reverseGraph,revPriorityQ,t,s);
-
-
-
-ArrayList<Integer> forgraphprocessedVertices = new ArrayList<Integer>();
-ArrayList<Integer> revgraphprocessedVertices = new ArrayList<Integer>();
-
+graph[s].dist=0; //initialized source distance zero.
+reverseGraph[t].dist=0; //initialized target distance to zero.
 
+queue.makeQueue(graph,forwPriorityQ,s,t); //makes forwardQ.
+queue.makeQueue(reverseGraph,revPriorityQ,t,s); // makes revQ.
 
+ArrayList<Integer> forgraphprocessedVertices = new ArrayList<Integer>(); //to store vertices processed in the forward search.
+ArrayList<Integer> revgraphprocessedVertices = new ArrayList<Integer>(); //to store vertices processed in the backward search.
+
 for(int i=0;i<graph.length;i++){
-int vertex1 = queue.extractMin(graph,forwPriorityQ,i);
+int vertex1 = queue.extractMin(graph,forwPriorityQ,i); //extracted the vertex with min distance.
 if(graph[vertex1].dist==Integer.MAX_VALUE){
 continue;
 }
-relaxEdges(graph,vertex1,forwPriorityQ,queue,queryId);
-forgraphprocessedVertices.add(vertex1);
+relaxEdges(graph,vertex1,forwPriorityQ,queue,queryId); //relaxed the edges.
+forgraphprocessedVertices.add(vertex1); //added in the forward lsit.
 
+//check wether we have found vertex processed both in forward and backward then return the shortest path.
 if(reverseGraph[vertex1].processed){
 return shortestPath(graph,reverseGraph,forgraphprocessedVertices,revgraphprocessedVertices,queryId);
 }
 
 
-int revVertex = queue.extractMin(reverseGraph,revPriorityQ,i);
+int revVertex = queue.extractMin(reverseGraph,revPriorityQ,i); //extracted min distance vertex in backward search.
 if(reverseGraph[revVertex].dist==Integer.MAX_VALUE){
 continue;
 }
-relaxEdges(reverseGraph,revVertex,revPriorityQ,queue,queryId);
-revgraphprocessedVertices.add(revVertex);
+relaxEdges(reverseGraph,revVertex,revPriorityQ,queue,queryId); //relaxed edges in the backward search.
+revgraphprocessedVertices.add(revVertex); //added the vertex to backward search processed list.
 
+//check whether the vertex is processed in forward search as well then return shortest distance.
 if(graph[revVertex].processed){
 return shortestPath(graph,reverseGraph,forgraphprocessedVertices,revgraphprocessedVertices,queryId);
 }
-
 }
 
-/*while(forwQ.size()!=0 || revQ.size()!=0){
-
-Vertex vertex = forwQ.poll();
-if(vertex!=null){
-relaxEdges(graph,vertex.vertexNum,forwQ,queryId);
-forgraphprocessedVertices.add(vertex.vertexNum);
-
-if(reverseGraph[vertex.vertexNum].processed.queryId==queryId && reverseGraph[vertex.vertexNum].processed.processed){
-return shortestPath(graph,reverseGraph,forgraphprocessedVertices,revgraphprocessedVertices,queryId);
-}
-}
-
-Vertex revVertex = revQ.poll();
-if(revVertex!=null){
-relaxEdges(reverseGraph,revVertex.vertexNum,revQ,queryId);
-revgraphprocessedVertices.add(revVertex.vertexNum);
-
-if(graph[revVertex.vertexNum].processed.queryId==queryId && graph[revVertex.vertexNum].processed.processed){
-return shortestPath(graph,reverseGraph,forgraphprocessedVertices,revgraphprocessedVertices,queryId);
-}
-}
-
-}*/
 return -1;
  }
 
 
+ //function to calculate shortest distance.
  private static long shortestPath(Vertex [] graph, Vertex [] reverseGraph, ArrayList<Integer> forgraphprocessedVertices, ArrayList<Integer> revgraphprocessedVertices,int queryId){
 long distance = Integer.MAX_VALUE;
 
 for(int i=0;i<forgraphprocessedVertices.size();i++){
 int vertex = forgraphprocessedVertices.get(i);
-/*if(reverseGraph[vertex].distance.queryId!=queryId || reverseGraph[vertex].distance.distance + graph[vertex].distance.distance>=Integer.MAX_VALUE){
-continue;
-}*/
 if(reverseGraph[vertex].dist + graph[vertex].dist>=Integer.MAX_VALUE){
 continue;
 }
@@ -260,9 +183,6 @@ private static long shortestPath(Vertex [] graph, Vertex [] reverseGraph, ArrayL
 
 for(int i=0;i<revgraphprocessedVertices.size();i++){
 int vertex = revgraphprocessedVertices.get(i);
-/*if(graph[vertex].distance.queryId!=queryId || reverseGraph[vertex].distance.distance + graph[vertex].distance.distance>=Integer.MAX_VALUE){
-continue;
-}*/
 if(reverseGraph[vertex].dist + graph[vertex].dist>=Integer.MAX_VALUE){
 continue;
 }
@@ -276,14 +196,16 @@ private static long shortestPath(Vertex [] graph, Vertex [] reverseGraph, ArrayL
  }
 
 
+
+ //main function to drive the program.
  public static void main(String args[]) {
 Scanner in = new Scanner(System.in);
- int n = in.nextInt();
-int m = in.nextInt();
+ int n = in.nextInt(); //number of vertices.
+int m = in.nextInt(); //number of edges.
 
-Vertex vertex = new Vertex();
-Vertex [] graph = new Vertex[n];
-Vertex [] reverseGraph = new Vertex[n];
+Vertex vertex = new Vertex(); 
+Vertex [] graph = new Vertex[n]; //graph for forward search.
+Vertex [] reverseGraph = new Vertex[n]; //graph for backward search.
 
 for(int i=0;i<n;i++){
 graph[i]=new Vertex(i);
@@ -294,7 +216,7 @@ public static void main(String args[]) {
 int u, v;
 int w;
 u= in.nextInt();
-v=in.nextInt();
+v=in.nextInt(); 
 w=in.nextInt();
 
 graph[u-1].adjList.add(v-1);
@@ -304,7 +226,7 @@ public static void main(String args[]) {
 reverseGraph[v-1].costList.add(w);
 }
 
-int q = in.nextInt();
+int q = in.nextInt(); //number of queries.
 
  for (int i = 0; i < q; i++) {
  int s, t;