├── A-Star
    ├── A star
    │   └── DistWithCoords.java
    └── Bidirectional A-Star
    │   └── DistWithCoords.java
├── Bidirectional Dijkstra
    └── FriendSuggestion.java
├── Contraction Hierarchies
    └── DistPreprocessSmall.java
├── LICENSE
└── README.md


/A-Star/A star/DistWithCoords.java:
--------------------------------------------------------------------------------
  1 | //Program to Implement A-Start Agorithm.
  2 | 
  3 | import java.util.Scanner;
  4 | import java.util.ArrayList;
  5 | import java.util.Arrays;
  6 | import java.util.PriorityQueue;
  7 | import java.lang.Math;
  8 | 
  9 | public class DistWithCoords {
 10 |     //class for a Vertex in the Graph.
 11 |     static class Vertex{
 12 | 	int vertexNum;                 //id of the vertex.
 13 | 	int x;                         //x co-ordinate of the vertex.
 14 | 	int y;                         //y co-ordinate of the vertex.
 15 | 	long distance;                 //distance of the vertex from the source. 
 16 | 	long potential;                //euclidean distance of the vertex and target vertex.
 17 | 	long distwithPotential;        //combining i.e suming distance and potential.
 18 | 	int queuePos;                  //pos of the vertex in the PriorityQueue.
 19 | 	boolean processed;             //check if the vertex is processed while traversing the graph. 
 20 | 	ArrayList<Integer> adjList;    //list of adjacent vertices from this vertex.
 21 | 	ArrayList<Integer> costList;   //list of costs or distances of adjacent vertices from this vertex.
 22 | 	
 23 | 	public Vertex(){
 24 | 	}
 25 | 
 26 | 	public Vertex(int vertexNum, int x, int y){
 27 | 		this.vertexNum=vertexNum;
 28 | 		this.x=x;
 29 | 		this.y=y;
 30 | 		this.adjList=new ArrayList<Integer>();
 31 | 		this.costList=new ArrayList<Integer>();
 32 | 	}
 33 | 
 34 |     }
 35 | 
 36 |     //Implementing PriorityQueue data structure by myself for this program. (using Min-Heap property.)
 37 |     static class PriorityQueue{
 38 | 	//function to swap elements int the priorityQ.
 39 | 	public void swap(Vertex [] graph, int [] priorityQ, int index1, int index2){
 40 | 		int temp = priorityQ[index1];
 41 | 
 42 | 		priorityQ[index1]=priorityQ[index2];
 43 | 		graph[priorityQ[index2]].queuePos=index1;
 44 | 
 45 | 		priorityQ[index2]=temp;
 46 | 		graph[temp].queuePos=index2;
 47 | 	}
 48 | 
 49 | 	//function to swap the source vertex with the first element in the priorityQ.		
 50 | 	public void makeQueue(Vertex [] graph,int [] forwpriorityQ, int source, int target){
 51 | 		swap(graph, forwpriorityQ,0,source);
 52 | 	}
 53 | 
 54 | 	//function to extract the min element from the priorityQ. based on the distwithPotential attribute.
 55 | 	public int extractMin(Vertex [] graph, int [] priorityQ, int extractNum){
 56 | 		int vertex = priorityQ[0];
 57 | 		int size = priorityQ.length-1-extractNum;
 58 | 		swap(graph,priorityQ,0,size);
 59 | 		siftDown(0,graph,priorityQ,size);
 60 | 		return vertex;
 61 | 	}
 62 | 
 63 | 	//function to siftdown the element at the given index in the priorityQ.
 64 | 	public void siftDown(int index, Vertex [] graph, int [] priorityQ, int size){
 65 | 		int min = index;
 66 | 		if(2*index+1<size && graph[priorityQ[index]].distwithPotential > graph[priorityQ[2*index+1]].distwithPotential){
 67 | 			min = 2*index+1;
 68 | 		}
 69 | 		if(2*index+2<size && graph[priorityQ[min]].distwithPotential > graph[priorityQ[2*index+2]].distwithPotential){
 70 | 			min = 2*index+2;
 71 | 		}
 72 | 		if(min!=index){
 73 | 			swap(graph,priorityQ,min,index);
 74 | 			siftDown(min,graph,priorityQ,size);
 75 | 		}
 76 | 	}
 77 | 	
 78 | 	//function to change the priority of an element in the priorityQ. (priority can only decrease).
 79 | 	public void changePriority(Vertex [] graph, int [] priorityQ, int index){
 80 | 		if((index-1)/2 > -1 && graph[priorityQ[index]].distwithPotential < graph[priorityQ[(index-1)/2]].distwithPotential){
 81 | 			swap(graph,priorityQ,index,(index-1)/2);
 82 | 			changePriority(graph,priorityQ,(index-1)/2);
 83 | 		}
 84 | 	}
 85 |     }
 86 | 	
 87 | 
 88 |     //function to calculate the euclidean distance between two vertices.
 89 |     private static long calcPotential(Vertex [] graph, int vertex1, int vertex2){
 90 | 	long potential = (long)Math.sqrt(Math.pow((graph[vertex1].x - graph[vertex2].x),2) + Math.pow((graph[vertex1].y - graph[vertex2].y),2));
 91 | 	return potential;
 92 |     }
 93 | 
 94 |     //function to initialize the graph.
 95 |     public static void initialize(Vertex [] graph, int [] forwpriorityQ, int source, int target){
 96 | 	for(int i=0;i<graph.length;i++){
 97 | 		graph[i].processed = false;
 98 | 		graph[i].distance = Long.MAX_VALUE;
 99 | 		graph[i].distwithPotential = Long.MAX_VALUE;
100 | 		graph[i].potential = calcPotential(graph, i, target);
101 | 		forwpriorityQ[i]=i;
102 | 	    	graph[i].queuePos=i;
103 | 		
104 | 	}
105 | 	graph[source].distance = 0;
106 | 	graph[source].distwithPotential = 0;
107 | 	
108 | 	
109 |     }
110 | 
111 | 
112 |     //function to relax the edges i.e process every adjacent edge of the given vertex.
113 |     private static void relaxEdges(Vertex [] graph, int [] priorityQ, int vertex, PriorityQueue queue){
114 | 	ArrayList<Integer> vertexList = graph[vertex].adjList;
115 | 	ArrayList<Integer> costList = graph[vertex].costList;
116 | 	graph[vertex].processed = true;
117 | 	
118 | 	for(int i=0;i<vertexList.size();i++){
119 | 		int temp =vertexList.get(i);
120 | 		int cost = costList.get(i);
121 | 		
122 | 		if(graph[temp].distance > graph[vertex].distance + cost){
123 | 			graph[temp].distance = graph[vertex].distance + cost;
124 | 			graph[temp].distwithPotential = graph[temp].distance + graph[temp].potential;
125 | 			queue.changePriority(graph,priorityQ,graph[temp].queuePos);
126 | 		}
127 | 	}
128 |     }
129 |  
130 | 
131 |     //function to compute the distance between soure and the target.
132 |     public static long computeDist(Vertex [] graph, int source, int target){
133 | 	//create priorityQ.
134 | 	int [] forwpriorityQ = new int[graph.length];
135 | 
136 | 	//initialize the graph.
137 | 	initialize(graph,forwpriorityQ,source,target);	
138 | 
139 | 	PriorityQueue queue = new PriorityQueue();
140 | 	queue.makeQueue(graph, forwpriorityQ,source,target);
141 | 
142 | 	for(int i=0;i<graph.length;i++){
143 | 		//extact the element with the min
144 | 		int vertex1 = queue.extractMin(graph,forwpriorityQ,i);
145 | 		
146 | 		if(graph[vertex1].distance == (Long.MAX_VALUE)){
147 | 			return -1;
148 | 		}
149 | 		
150 | 		//if target vertex found return the distance.
151 | 		if(vertex1==target){
152 | 			return graph[vertex1].distance;
153 | 		}
154 | 		
155 | 		//else relax the edges of the extracted vertex.
156 | 		relaxEdges(graph,forwpriorityQ,vertex1,queue);
157 | 		
158 | 	}
159 | 	
160 | 	//if no path between source and target vertex.
161 | 	return -1;
162 |     }
163 | 
164 |     
165 |     //main function to run the program.
166 |     public static void main(String args[]) {
167 |         Scanner in = new Scanner(System.in);
168 |         int n = in.nextInt();   //number of vertices in the graph.
169 |         int m = in.nextInt();   //number of edges in the graph.
170 | 
171 | 	//create the graph.
172 | 	Vertex [] graph = new Vertex[n];  
173 | 
174 | 	//get the co-ordinates of every vertex.	
175 | 	for (int i = 0; i < n; i++) { 
176 |             int x, y;
177 |             x = in.nextInt();
178 |             y = in.nextInt();
179 | 	    graph[i] = new Vertex(i,x,y);
180 | 	}
181 | 
182 | 	//get the edges in the graph.
183 |         for (int i = 0; i < m; i++) {
184 |             int x, y, c;
185 |             x = in.nextInt();
186 |             y = in.nextInt();
187 |             c = in.nextInt();
188 | 
189 | 	    graph[x-1].adjList.add(y-1);
190 | 	    graph[x-1].costList.add(c);
191 | 
192 | 	}
193 | 
194 | 	//number of queries.
195 |         int q = in.nextInt();
196 | 
197 |         for (int i = 0; i < q; i++) {
198 |             int s, t;
199 |             s = in.nextInt()-1;
200 |             t = in.nextInt()-1;
201 |             System.out.println(computeDist(graph,s,t));
202 |         }
203 |     }
204 | }


--------------------------------------------------------------------------------
/A-Star/Bidirectional A-Star/DistWithCoords.java:
--------------------------------------------------------------------------------
  1 | //Program to implement Bidirectional A-Star Algorithm.
  2 | 
  3 | import java.util.Scanner;
  4 | import java.util.ArrayList;
  5 | import java.util.Arrays;
  6 | import java.util.PriorityQueue;
  7 | import java.lang.Math;
  8 | 
  9 | public class DistWithCoords {
 10 | 
 11 |     //class Vertex of the Graph.    
 12 |     static class Vertex{
 13 | 	int vertexNum;                  //id of the vertex.
 14 | 	int x;				//x co-oridnate of the vertex.
 15 | 	int y;				//y co-ordinate of the vertex.
 16 | 	long distance;			//distance of this vertex from the source vertex.
 17 | 	long potential;			//euclidean distance of this vertex and target vertex.
 18 | 	long distwithPotential;		//summing potential and distance
 19 | 	int queuePos;			//pos of this vertex in the PriorityQueue.
 20 | 	boolean processed;		//check if processed while traversing the graph.
 21 | 	ArrayList<Integer> adjList;	//list of adjacent vertices from this vertex.
 22 | 	ArrayList<Integer> costList;	//list of costs or distances of adjacent vertices from this vertex.
 23 | 	
 24 | 	public Vertex(){
 25 | 	}
 26 | 
 27 | 	public Vertex(int vertexNum, int x, int y){
 28 | 		this.vertexNum=vertexNum;
 29 | 		this.x=x;
 30 | 		this.y=y;
 31 | 		this.adjList=new ArrayList<Integer>();
 32 | 		this.costList=new ArrayList<Integer>();
 33 | 	}
 34 | 
 35 |     }
 36 | 
 37 | 
 38 |     //Implemented PriorityQueue Data Structure by myself.(using Min-Heap Property)
 39 |     static class PriorityQueue{
 40 | 	//function to swap values in the priorityQ.
 41 | 	public void swap(Vertex [] graph, int [] priorityQ, int index1, int index2){
 42 | 		int temp = priorityQ[index1];
 43 | 
 44 | 		priorityQ[index1]=priorityQ[index2];
 45 | 		graph[priorityQ[index2]].queuePos=index1;
 46 | 
 47 | 		priorityQ[index2]=temp;
 48 | 		graph[temp].queuePos=index2;
 49 | 	}
 50 | 		
 51 | 	//function to swap source vertex with the first vertex int he priorityQ.
 52 | 	public void makeQueue(Vertex [] graph, Vertex [] reverseGraph, int [] forwpriorityQ, int [] revpriorityQ, int source, int target){
 53 | 		swap(graph, forwpriorityQ,0,source);
 54 | 		swap(reverseGraph, revpriorityQ,0,target);
 55 | 	}
 56 | 
 57 | 	//function to extract the vertex with min distwithpotential value from the PriorityQueue.
 58 | 	public int extractMin(Vertex [] graph, int [] priorityQ, int extractNum){
 59 | 		int vertex = priorityQ[0];
 60 | 		int size = priorityQ.length-1-extractNum;
 61 | 		swap(graph,priorityQ,0,size);
 62 | 		siftDown(0,graph,priorityQ,size);
 63 | 		return vertex;
 64 | 	}
 65 | 
 66 | 
 67 | 	//function to siftdown the vertex in the priotityQ.
 68 | 	public void siftDown(int index, Vertex [] graph, int [] priorityQ, int size){
 69 | 		int min = index;
 70 | 		if(2*index+1<size && graph[priorityQ[index]].distwithPotential > graph[priorityQ[2*index+1]].distwithPotential){
 71 | 			min = 2*index+1;
 72 | 		}
 73 | 		if(2*index+2<size && graph[priorityQ[min]].distwithPotential > graph[priorityQ[2*index+2]].distwithPotential){
 74 | 			min = 2*index+2;
 75 | 		}
 76 | 		if(min!=index){
 77 | 			swap(graph,priorityQ,min,index);
 78 | 			siftDown(min,graph,priorityQ,size);
 79 | 		}
 80 | 	}
 81 | 	
 82 | 	//function to change the prirority of a vertex. (can only decrease the priority).
 83 | 	public void changePriority(Vertex [] graph, int [] priorityQ, int index){
 84 | 		if((index-1)/2 > -1 && graph[priorityQ[index]].distwithPotential < graph[priorityQ[(index-1)/2]].distwithPotential){
 85 | 			swap(graph,priorityQ,index,(index-1)/2);
 86 | 			changePriority(graph,priorityQ,(index-1)/2);
 87 | 		}
 88 | 	}
 89 |     }
 90 | 
 91 | 
 92 |     //function to calculate the potential of the vertex i.e euclidean distance between two vertices.		
 93 |     private static long calcPotential(Vertex [] graph, int vertex1, int vertex2){
 94 | 	long potential = (long)Math.sqrt(Math.pow((graph[vertex1].x - graph[vertex2].x),2) + Math.pow((graph[vertex1].y - graph[vertex2].y),2));
 95 | 	return potential;
 96 |     }
 97 | 
 98 | 	
 99 |     //function to initialize the graph.
100 |     public static void initialize(Vertex [] graph, Vertex [] reverseGraph, int [] forwpriorityQ, int [] revpriorityQ, int source, int target){
101 | 	for(int i=0;i<graph.length;i++){
102 | 		graph[i].processed = false;
103 | 		graph[i].distance = Long.MAX_VALUE;
104 | 		graph[i].distwithPotential = Long.MAX_VALUE;
105 | 		graph[i].potential = (calcPotential(graph, i, target) - calcPotential(graph,i,source))/2;
106 | 		forwpriorityQ[i]=i;
107 | 		graph[i].queuePos=i;
108 | 		
109 | 		reverseGraph[i].processed = false;
110 | 		reverseGraph[i].distance = (Long.MAX_VALUE);
111 | 		reverseGraph[i].distwithPotential = (Long.MAX_VALUE);
112 | 		reverseGraph[i].potential = (calcPotential(reverseGraph,i,source)-calcPotential(reverseGraph,i,target))/2;
113 | 		revpriorityQ[i]=i;
114 | 		reverseGraph[i].queuePos=i;
115 | 	}
116 | 	graph[source].distance = 0;
117 | 	graph[source].distwithPotential = 0;
118 | 	reverseGraph[target].distance = 0;
119 | 	reverseGraph[target].distwithPotential=0;
120 |     }
121 | 
122 | 
123 |     //function to relax the edges of the given vertex i.e process the adjacent edges.
124 |     private static void relaxEdges(Vertex [] graph, int [] priorityQ, int vertex, PriorityQueue queue){
125 | 	ArrayList<Integer> vertexList = graph[vertex].adjList;
126 | 	ArrayList<Integer> costList = graph[vertex].costList;
127 | 	graph[vertex].processed = true;
128 | 	
129 | 	for(int i=0;i<vertexList.size();i++){
130 | 		int temp =vertexList.get(i);
131 | 		int cost = costList.get(i);
132 | 		
133 | 		if(graph[temp].distance > graph[vertex].distance + cost){
134 | 			graph[temp].distance = graph[vertex].distance + cost;
135 | 			graph[temp].distwithPotential = graph[temp].distance + graph[temp].potential ;
136 | 			queue.changePriority(graph,priorityQ,graph[temp].queuePos);
137 | 		}
138 | 	}
139 |     }
140 | 
141 |     
142 |     //function to find the correct distance of the vertex.
143 |     public static void correctDistance(Vertex [] graph, Vertex [] reverseGraph, int vertex, long correctDist){
144 | 	if(graph[vertex].distance == Long.MAX_VALUE || reverseGraph[vertex].distance == Long.MAX_VALUE){
145 | 		return;
146 | 	}
147 | 	if(correctDist>graph[vertex].distance + reverseGraph[vertex].distance){
148 | 		correctDist = graph[vertex].distance + reverseGraph[vertex].distance;
149 | 	}
150 |     } 
151 | 
152 |     //function to compute the distance between the source vertex and the target vertex.
153 |     public static long computeDist(Vertex [] graph, Vertex [] reverseGraph, int source, int target){
154 | 	//create the PriorityQueue's
155 | 	int [] forwpriorityQ = new int[graph.length];   //for forward propagation
156 | 	int [] revpriorityQ = new int[graph.length];    //for reverse graph i.e backward propagation.
157 | 	 
158 | 	//initialize the graph.
159 | 	initialize(graph,reverseGraph,forwpriorityQ,revpriorityQ,source,target);	
160 | 
161 | 	PriorityQueue queue = new PriorityQueue();
162 | 	queue.makeQueue(graph, reverseGraph, forwpriorityQ, revpriorityQ, source,target);
163 | 
164 | 	ArrayList<Integer> forwprocessedVertices = new ArrayList<Integer>();   //list to store the processed vertices in the forward propagation.
165 | 	ArrayList<Integer> revprocessedVertices = new ArrayList<Integer>();    //list to store the processed vertices in the reverse graph. i.e backward propagation.
166 | 	long correctDist = Long.MAX_VALUE;
167 | 	
168 | 	for(int i=0;i<graph.length;i++){
169 | 		int vertex1 = queue.extractMin(graph,forwpriorityQ,i);          //extract the min vertex from the forward graph.
170 | 		int vertex2 = queue.extractMin(reverseGraph, revpriorityQ, i);  //extract the min vertex from the reverse graph.
171 | 		
172 | 		if(graph[vertex1].distance == (Long.MAX_VALUE) || reverseGraph[vertex2].distance == (Long.MAX_VALUE)){
173 | 			return -1;
174 | 		}
175 | 		
176 | 		//relax the edges. 
177 | 		relaxEdges(graph,forwpriorityQ,vertex1,queue);
178 | 		
179 | 		//store the vertex in the forward list.
180 | 		forwprocessedVertices.add(vertex1);
181 | 
182 | 		//find the correct distance.
183 | 		correctDistance(graph,reverseGraph,vertex1,correctDist);
184 | 
185 | 		//if also processed in the reverse graph then compute shortest distance.
186 | 		if(graph[vertex1].processed && reverseGraph[vertex1].processed){
187 | 			return shortestPath(graph,reverseGraph,forwprocessedVertices, revprocessedVertices,vertex1, correctDist);
188 | 		}
189 | 
190 | 		//relax the edges of the min vertex in the reverse graph.
191 | 		relaxEdges(reverseGraph,revpriorityQ,vertex2,queue);
192 | 		
193 | 		//add into the reverse processed list.
194 | 		revprocessedVertices.add(vertex2);
195 | 
196 | 		//compute the correct the distance.
197 | 		correctDistance(graph,reverseGraph,vertex2,correctDist);
198 | 
199 | 		//if processed in the forward graph, compute the shortest distance.
200 | 		if(reverseGraph[vertex2].processed && graph[vertex2].processed){
201 | 			return shortestPath(graph,reverseGraph,forwprocessedVertices, revprocessedVertices,vertex2,correctDist);
202 | 		}
203 | 	}
204 | 
205 | 	//if no path between sorce vertex and target vertex.
206 | 	return -1;
207 |     }
208 | 
209 |    
210 |     //function to compute the shortest path of all the processed vertives in both forward and reverse propagation.
211 |     public static long shortestPath(Vertex [] graph, Vertex [] reverseGraph, ArrayList<Integer> forwprocessedVertices, ArrayList<Integer> revprocessedVertices, int vertex,long correctDist){
212 | 	long distance = Long.MAX_VALUE;
213 | 
214 | 	//process the list of forward processed vertices.
215 | 	for(int i=0;i<forwprocessedVertices.size();i++){
216 | 		int temp = forwprocessedVertices.get(i);
217 | 		if(reverseGraph[temp].distance != Long.MAX_VALUE && distance > graph[temp].distance + reverseGraph[temp].distance){
218 | 			distance = graph[temp].distance + reverseGraph[temp].distance;
219 | 		}
220 | 	}
221 | 
222 | 	//process the list of reverse processed vertices.
223 | 	for(int i=0;i<revprocessedVertices.size();i++){
224 | 		int temp = revprocessedVertices.get(i);
225 | 		if(graph[temp].distance != Long.MAX_VALUE && distance > graph[temp].distance + reverseGraph[temp].distance){
226 | 			distance = graph[temp].distance + reverseGraph[temp].distance;
227 | 		}
228 | 	}
229 | 		
230 | 	return distance;
231 |     }
232 | 		
233 | 
234 |     //main function to run the program.	
235 |     public static void main(String args[]) {
236 |         Scanner in = new Scanner(System.in);
237 | 	System.out.println("Enter the number of vertices and edges.");
238 |         int n = in.nextInt();   //number of vertices.
239 |         int m = in.nextInt();   //number of edges.
240 | 	
241 | 	//create forward and reverse graph.
242 | 	Vertex [] graph = new Vertex[n];
243 | 	Vertex [] reverseGraph = new Vertex[n];
244 | 	
245 | 	//get the co-ordinates of the vertices.
246 | 	System.out.println("Enter the Coordinates.");
247 | 	for (int i = 0; i < n; i++) { 
248 |             int x, y;
249 |             x = in.nextInt();   //x co-or
250 |             y = in.nextInt();   //y co-or
251 | 	
252 | 	    graph[i] = new Vertex(i,x,y);
253 | 	    reverseGraph[i] = new Vertex(i,x,y);
254 |         }
255 | 
256 | 	
257 | 	//get the edges in the graph.
258 | 	System.out.println("Enter the edges with weights (V1 V2 W).");
259 |         for (int i = 0; i < m; i++) {
260 |             int x, y, c;
261 |             x = in.nextInt();
262 |             y = in.nextInt();
263 |             c = in.nextInt();
264 | 
265 | 	    graph[x-1].adjList.add(y-1);
266 | 	    graph[x-1].costList.add(c);
267 | 
268 | 	    reverseGraph[y-1].adjList.add(x-1);
269 | 	    reverseGraph[y-1].costList.add(c);
270 | 	}
271 | 
272 | 	System.out.println("Enter the number of queries.");
273 |         int q = in.nextInt(); //number of queries
274 | 
275 | 	System.out.println("Enter the queries (S T)");
276 |         for (int i = 0; i < q; i++) {
277 |             int s, t;
278 |             s = in.nextInt()-1;   //source vertex.
279 |             t = in.nextInt()-1;   //target vertex.
280 |             System.out.println(computeDist(graph,reverseGraph,s,t));
281 |         }
282 |     }
283 | }


--------------------------------------------------------------------------------
/Bidirectional Dijkstra/FriendSuggestion.java:
--------------------------------------------------------------------------------
  1 | //Program to implement the Bi-Directional Dijkstra Algorithm.
  2 | 
  3 | import java.util.Scanner;
  4 | import java.util.ArrayList;
  5 | import java.util.Arrays;
  6 | import java.util.PriorityQueue;
  7 | import java.util.Comparator;
  8 | 
  9 | public class FriendSuggestion {
 10 | 
 11 |     //class Vertex of Graph.
 12 |     static class Vertex{
 13 | 	int vertexNum;                  //int vertexNum
 14 | 	ArrayList<Integer> adjList;     //list of adjacent vertices.
 15 | 	ArrayList<Integer> costList;    //list of cost or distance of adjacent vertices.
 16 | 
 17 | 	int queuePos;                   //pos of vertex in the priorityqueue.
 18 | 	long dist;                      //distance from start vetex.    
 19 | 	boolean processed;              //is processed while traversing the graph.
 20 | 
 21 | 	public Vertex(){
 22 | 	}
 23 | 
 24 | 
 25 | 	//Vertex Constructor.
 26 | 	public Vertex(int vertexNum){
 27 | 		this.vertexNum=vertexNum;
 28 | 		this.adjList = new ArrayList<Integer>();
 29 | 		this.costList = new ArrayList<Integer>();
 30 | 	}
 31 | 
 32 | 
 33 | 	//function to create the graph and reverse graph. forwPriorityQ for graph and revPriorityQ for reverse graph.
 34 | 	public void createGraph(Vertex [] graph, Vertex [] reverseGraph, int [] forwPriorityQ, int [] revPriorityQ){
 35 | 		for(int i=0;i<graph.length;i++){
 36 | 			graph[i].queuePos = i;
 37 | 			graph[i].processed = false;
 38 | 			graph[i].dist = Integer.MAX_VALUE;
 39 | 		
 40 | 			reverseGraph[i].queuePos = i;
 41 | 			reverseGraph[i].processed = false;
 42 | 			reverseGraph[i].dist = Integer.MAX_VALUE;
 43 | 
 44 | 			forwPriorityQ[i]=i;
 45 | 			revPriorityQ[i]=i;
 46 | 		}
 47 | 	}
 48 |     }
 49 | 
 50 | 
 51 |     //Implementing PrioirtyQueue data structure by myself using min_heap property. 
 52 |     static class PriorityQueue{
 53 | 
 54 | 	//function to swap elements in the PriorityQueue
 55 | 	public void swap(Vertex [] graph, int [] priorityQ, int index1, int index2){
 56 | 		int temp = priorityQ[index1];
 57 | 
 58 | 		priorityQ[index1]=priorityQ[index2];
 59 | 		graph[priorityQ[index2]].queuePos=index1;
 60 | 
 61 | 		priorityQ[index2]=temp;
 62 | 		graph[temp].queuePos=index2;
 63 | 	}
 64 | 
 65 | 	//function to swap start vertex and first vertex in the priorityQ.		
 66 | 	public void makeQueue(Vertex [] graph,int [] forwpriorityQ, int source, int target){
 67 | 		swap(graph, forwpriorityQ,0,source);
 68 | 	}
 69 | 
 70 | 
 71 | 	//function to extract the min value from the PriorityQueue	
 72 | 	public int extractMin(Vertex [] graph, int [] priorityQ, int extractNum){
 73 | 		int vertex = priorityQ[0];
 74 | 		int size = priorityQ.length-1-extractNum;
 75 | 		swap(graph,priorityQ,0,size);
 76 | 		siftDown(0,graph,priorityQ,size);
 77 | 		return vertex;
 78 | 	}
 79 | 
 80 | 	//function to siftdown the element at the given index in the PriorityQueue.
 81 | 	public void siftDown(int index, Vertex [] graph, int [] priorityQ, int size){
 82 | 		int min = index;
 83 | 		if(2*index+1<size && graph[priorityQ[index]].dist > graph[priorityQ[2*index+1]].dist){
 84 | 			min = 2*index+1;
 85 | 		}
 86 | 		if(2*index+2<size && graph[priorityQ[min]].dist > graph[priorityQ[2*index+2]].dist){
 87 | 			min = 2*index+2;
 88 | 		}
 89 | 		if(min!=index){
 90 | 			swap(graph,priorityQ,min,index);
 91 | 			siftDown(min,graph,priorityQ,size);
 92 | 		}
 93 | 	}
 94 | 	
 95 | 	//function to change priority of an element.(priority can only be decreased.)
 96 | 	public void changePriority(Vertex [] graph, int [] priorityQ, int index){
 97 | 		if((index-1)/2 > -1 && graph[priorityQ[index]].dist < graph[priorityQ[(index-1)/2]].dist){
 98 | 			swap(graph,priorityQ,index,(index-1)/2);
 99 | 			changePriority(graph,priorityQ,(index-1)/2);
100 | 		}
101 | 	}
102 |     }
103 |    
104 |     //function to relax edges i.e traverse only the adjacent vertices of the given vertex.
105 |     private static void relaxEdges(Vertex [] graph, int vertex, int [] priorityQ, PriorityQueue queue,int queryId){
106 | 	ArrayList<Integer> vertexList = graph[vertex].adjList;   //get the adjacent vertices list.
107 | 	ArrayList<Integer> costList = graph[vertex].costList;    //get the cost list of adjacent vertices.
108 | 	graph[vertex].processed = true;  			 //mark processed true.
109 | 	
110 | 	for(int i=0;i<vertexList.size();i++){
111 | 		int temp = vertexList.get(i);
112 | 		int cost = costList.get(i);
113 | 	
114 | 		if(graph[temp].dist>graph[vertex].dist + cost){
115 | 			graph[temp].dist = graph[vertex].dist + cost;	
116 | 			queue.changePriority(graph,priorityQ,graph[temp].queuePos);
117 | 		}
118 | 	}
119 |     }
120 | 
121 |     
122 |     //function to compute distance between start vertex s and target vertex t.   
123 |     public static long computeDistance(Vertex [] graph, Vertex [] reverseGraph, int s, int t,int queryId){
124 | 	
125 | 	//create two PriorityQueues forwQ for forward graph and revQ for reverse graph. 
126 | 	PriorityQueue queue = new PriorityQueue();
127 | 	int [] forwPriorityQ = new int[graph.length];  //for forward propagation.
128 | 	int [] revPriorityQ = new int[graph.length];   //for reverse propagation.
129 | 
130 | 	//create graph.
131 | 	Vertex vertex = new Vertex();
132 | 	vertex.createGraph(graph,reverseGraph,forwPriorityQ,revPriorityQ);
133 | 
134 | 	//dist of s from s is 0.
135 | 	//in rev graph dist of t from t is 0.
136 | 	graph[s].dist=0;
137 | 	reverseGraph[t].dist=0;
138 | 	queue.makeQueue(graph,forwPriorityQ,s,t);
139 | 	queue.makeQueue(reverseGraph,revPriorityQ,t,s);
140 | 
141 | 	//store the processed vertices while traversing.
142 | 	ArrayList<Integer> forgraphprocessedVertices = new ArrayList<Integer>();  //for forward propagation.
143 | 	ArrayList<Integer> revgraphprocessedVertices = new ArrayList<Integer>();  //for reverse propagation.
144 | 	
145 | 	
146 | 	for(int i=0;i<graph.length;i++){
147 | 
148 | 		//extract the vertex with min dist from forwQ.
149 | 		int vertex1 = queue.extractMin(graph,forwPriorityQ,i);
150 | 		if(graph[vertex1].dist==Integer.MAX_VALUE){
151 | 			continue;
152 | 		}
153 | 
154 | 		//relax the edges of the extracted vertex.
155 | 		relaxEdges(graph,vertex1,forwPriorityQ,queue,queryId);
156 | 
157 | 		//store into the processed vertices list.
158 | 		forgraphprocessedVertices.add(vertex1);
159 | 
160 | 		//check if extratced vertex also processed in the reverse graph. If yes find the shortest distance.
161 | 		if(reverseGraph[vertex1].processed){
162 | 			return shortestPath(graph,reverseGraph,forgraphprocessedVertices,revgraphprocessedVertices,queryId);
163 | 		}
164 | 		
165 | 
166 | 		//extract the vertex with min dist from revQ.
167 | 		int revVertex = queue.extractMin(reverseGraph,revPriorityQ,i);
168 | 		if(reverseGraph[revVertex].dist==Integer.MAX_VALUE){
169 | 			continue;
170 | 		}
171 | 
172 | 		//relax the edges of the extracted vertex.
173 | 		relaxEdges(reverseGraph,revVertex,revPriorityQ,queue,queryId);
174 | 
175 | 		//store in the processed vertices list of reverse graph.
176 | 		revgraphprocessedVertices.add(revVertex);
177 | 		
178 | 		//check if extracted vertex is also processed in the forward graph. If yes find the shortest distance.
179 | 		if(graph[revVertex].processed){
180 | 			return shortestPath(graph,reverseGraph,forgraphprocessedVertices,revgraphprocessedVertices,queryId);
181 | 		}
182 | 		
183 | 	}
184 | 	
185 | 	//if no path between s and t.
186 | 	return -1;
187 |     }
188 | 
189 | 	
190 |     //function to find the shortest distance from the stored processed vertices of both forward and reverse graph.
191 |     private static long shortestPath(Vertex [] graph, Vertex [] reverseGraph, ArrayList<Integer> forgraphprocessedVertices, ArrayList<Integer> revgraphprocessedVertices,int queryId){
192 | 	long distance = Integer.MAX_VALUE;
193 | 	
194 | 	//process the forward list.
195 | 	for(int i=0;i<forgraphprocessedVertices.size();i++){
196 | 		int vertex = forgraphprocessedVertices.get(i);
197 | 		if(reverseGraph[vertex].dist + graph[vertex].dist>=Integer.MAX_VALUE){
198 | 			continue;
199 | 		}
200 | 		long tempdist = graph[vertex].dist + reverseGraph[vertex].dist;	
201 | 		if(distance>tempdist){
202 | 			distance=tempdist;
203 | 		}
204 | 	}
205 | 	
206 | 	//process the reverse list.
207 | 	for(int i=0;i<revgraphprocessedVertices.size();i++){
208 | 		int vertex = revgraphprocessedVertices.get(i);
209 | 		if(reverseGraph[vertex].dist + graph[vertex].dist>=Integer.MAX_VALUE){
210 | 			continue;
211 | 		}
212 | 		long tempdist = reverseGraph[vertex].dist + graph[vertex].dist;
213 | 		if(distance>tempdist){
214 | 			distance=tempdist;
215 | 		}
216 | 	
217 | 	}
218 | 	return distance;
219 |     }
220 |     
221 | 
222 |     //main function to run the program.
223 |     public static void main(String args[]) {
224 | 	Scanner in = new Scanner(System.in);
225 |         int n = in.nextInt();   //number of vertices.
226 | 	int m = in.nextInt();   //number of edges.
227 | 
228 | 	//create two graphs forw graph and reverse graph.
229 | 	Vertex vertex = new Vertex();
230 | 	Vertex [] graph = new Vertex[n];
231 | 	Vertex [] reverseGraph = new Vertex[n];
232 | 
233 | 	//initialize the vertices.
234 | 	for(int i=0;i<n;i++){
235 | 		graph[i]=new Vertex(i);
236 | 		reverseGraph[i]=new Vertex(i);
237 | 	}
238 | 	
239 | 	//get the edges.
240 | 	for(int i=0;i<m;i++){
241 | 		int u, v;
242 | 		int w;
243 | 		u= in.nextInt();  //start vertex
244 | 		v=in.nextInt();   //end vertex
245 | 		w=in.nextInt();   //weight of edge
246 | 
247 | 		graph[u-1].adjList.add(v-1);
248 | 		graph[u-1].costList.add(w);
249 | 
250 | 		reverseGraph[v-1].adjList.add(u-1);
251 | 		reverseGraph[v-1].costList.add(w);
252 | 	}
253 | 
254 | 	
255 | 	int q = in.nextInt(); //number of queries.
256 | 
257 | 	//get the queries
258 |         for (int i = 0; i < q; i++) {
259 |             int s, t;
260 |             s = in.nextInt()-1;   //source vertex
261 |             t = in.nextInt()-1;   //target vertex/
262 | 		
263 | 	    System.out.println(computeDistance(graph,reverseGraph,s,t,i));
264 | 	}
265 | 	
266 |     }
267 | }
268 | 


--------------------------------------------------------------------------------
/Contraction Hierarchies/DistPreprocessSmall.java:
--------------------------------------------------------------------------------
  1 | //Program to implement Contraction Hierarchies Algorithm.
  2 | 
  3 | import java.util.Scanner;
  4 | import java.util.ArrayList;
  5 | import java.util.Arrays;
  6 | import java.util.*;
  7 | import java.util.PriorityQueue;
  8 | import java.util.Comparator;
  9 | 
 10 | public class DistPreprocessSmall{
 11 | 
 12 |    static class Distance{
 13 | 	//Ids are made so that we dont have to reinitialize everytime the distance value to infinity.
 14 | 
 15 | 	int contractId;		//id for the vertex that is going to be contracted.
 16 | 	int sourceId;           //it contains the id of vertex for which we will apply dijkstra while contracting.
 17 | 	
 18 | 	long distance; 		//stores the value of distance while contracting.
 19 | 
 20 | 	//used in query time for bidirectional dijkstra algo
 21 | 	int forwqueryId; 	//for forward search.
 22 | 	int revqueryId; 	//for backward search.
 23 | 
 24 | 	long queryDist; 	//for forward distance.
 25 | 	long revDistance; 	//for backward distance.
 26 | 
 27 | 	public Distance(){
 28 | 		this.contractId = -1;
 29 | 		this.sourceId=-1;
 30 | 		
 31 | 		this.forwqueryId=-1;
 32 | 		this.revqueryId=-1;
 33 | 		
 34 | 		this.distance = Integer.MAX_VALUE;		
 35 | 
 36 | 		this.revDistance = Integer.MAX_VALUE;
 37 | 		this.queryDist = Integer.MAX_VALUE;
 38 | 	}
 39 |     }
 40 |   
 41 |     //in this ids are made for the same reason, to not have to reinitialize processed variable for every query in bidirectional dijkstra.
 42 |     static class Processed{
 43 | 	boolean forwProcessed; 	//is processed in forward search.
 44 | 	boolean revProcessed; 	//is processed in backward search.
 45 | 	int forwqueryId; 	//id for forward search.
 46 | 	int revqueryId; 	//id for backward search.
 47 | 
 48 | 	public Processed(){
 49 | 		this.forwqueryId=-1;
 50 | 		this.revqueryId=-1;
 51 | 	}
 52 |     }
 53 | 	
 54 |     //class for Vertex of a graph.
 55 |     static class Vertex{
 56 | 	int vertexNum;			//id of the vertex.
 57 | 	ArrayList<Integer> inEdges; 	//list of incoming edges to this vertex.
 58 | 	ArrayList<Long> inECost;	//list of incoming edges cost or distance.	
 59 | 	ArrayList<Integer> outEdges; 	//list of outgoing edges from this vertex.
 60 | 	ArrayList<Long> outECost;	//list of out edges cost or distance.
 61 | 	
 62 | 	int orderPos; 			//position of vertex in nodeOrderingQueue.
 63 | 	
 64 | 	boolean contracted; 		//to check if vertex is contracted
 65 | 	
 66 | 	Distance distance;
 67 | 	Processed processed;
 68 | 	
 69 | 	//parameters for computing importance according to which we will contract the vertices. Vertex wih least importance wil be contracted first.
 70 | 	int edgeDiff; 			//egdediff = sE - inE - outE. (sE=inE*outE , i.e number of shortcuts that we may have to add.)
 71 | 	long delNeighbors; 		//number of contracted neighbors.
 72 | 	int shortcutCover; 		//number of shortcuts to be introduced if this vertex is contracted.
 73 | 
 74 | 	long importance; 		//total importance = edgediff + shortcutcover + delneighbors.
 75 | 
 76 | 	public Vertex(){
 77 | 	}
 78 | 	
 79 | 	public Vertex(int vertexNum){
 80 | 		this.vertexNum=vertexNum;
 81 | 		this.inEdges = new ArrayList<Integer>();
 82 | 		this.outEdges = new ArrayList<Integer>();
 83 | 		this.inECost = new ArrayList<Long>();
 84 | 		this.outECost = new ArrayList<Long>();
 85 | 		this.distance = new Distance();
 86 | 		this.processed = new Processed();
 87 | 		this.delNeighbors = 0;
 88 | 		this.contracted=false;
 89 | 	}
 90 |     }
 91 |     
 92 |     
 93 |     //priorityQueue (based on min heap) dealing with importance parameter.
 94 |     public static class PQIMPcomparator implements Comparator<Vertex>{
 95 | 	public int compare(Vertex node1, Vertex node2){
 96 | 		if(node1.importance > node2.importance){
 97 | 			return 1;
 98 | 		}
 99 | 		if(node1.importance < node2.importance){
100 | 			return -1;
101 | 		}
102 | 		return 0;
103 | 	}
104 |     }
105 | 
106 |     
107 |     //priorityQueue (min heap) dealing with distance while preprocessing time.
108 |     static class PriorityQueueComp implements Comparator<Vertex>{
109 | 	public int compare(Vertex node1,Vertex node2){
110 | 		if(node1.distance.distance>node2.distance.distance){
111 | 			return 1;
112 | 		}
113 | 		if(node1.distance.distance<node2.distance.distance){
114 | 			return -1;
115 | 		}
116 | 		return 0;
117 | 	}
118 |     }
119 | 
120 | 
121 | 
122 |     //all functions dealing with preprocessing in this class.
123 |     static class PreProcess{
124 | 	Comparator<Vertex> comp = new PQIMPcomparator();
125 | 	PriorityQueue<Vertex> PQImp;  	//queue for importance parameter.
126 | 
127 | 	Comparator<Vertex> PQcomp = new PriorityQueueComp();
128 | 	PriorityQueue<Vertex> queue;	//queue for distance parameter. 
129 | 	
130 | 	
131 | 	//calculate initial importance for all vertices.
132 | 	private void computeImportance(Vertex [] graph){
133 | 		PQImp = new PriorityQueue<Vertex>(graph.length,comp);
134 | 		for(int i=0;i<graph.length;i++){
135 | 			graph[i].edgeDiff = (graph[i].inEdges.size() * graph[i].outEdges.size()) - graph[i].inEdges.size() - graph[i].outEdges.size();
136 | 			graph[i].shortcutCover = graph[i].inEdges.size() + graph[i].outEdges.size();
137 | 			graph[i].importance = graph[i].edgeDiff*14+ graph[i].shortcutCover*25 + graph[i].delNeighbors*10;
138 | 			PQImp.add(graph[i]);
139 | 		}
140 | 	}
141 | 
142 | 
143 | 	//compute importance for individual vertex while processing.
144 | 	private void computeImportance(Vertex [] graph, Vertex vertex){
145 | 		vertex.edgeDiff = (vertex.inEdges.size() * vertex.outEdges.size()) - vertex.inEdges.size() - vertex.outEdges.size();
146 | 		vertex.shortcutCover = vertex.inEdges.size() + vertex.outEdges.size();
147 | 		vertex.importance = vertex.edgeDiff*14 + vertex.shortcutCover*25 + vertex.delNeighbors*10;
148 | 	}
149 | 	
150 | 	
151 | 	//function that will pre-process the graph.
152 | 	private int [] preProcess(Vertex [] graph){
153 | 		int [] nodeOrdering = new int[graph.length];	//contains the vertices in the order they are contracted.
154 | 		int extractNum=0; 				//stores the number of vertices that are contracted.
155 | 		
156 | 		while(PQImp.size()!=0){
157 | 			Vertex vertex = (Vertex)PQImp.poll();
158 | 			computeImportance(graph,vertex);	//recompute importance before contracting the vertex.
159 | 			
160 | 			//if the vertex's recomputed importance is still minimum then contract it.
161 | 			if(PQImp.size()!=0 && vertex.importance > PQImp.peek().importance){
162 | 				PQImp.add(vertex);
163 | 				continue;
164 | 			}
165 | 		
166 | 			nodeOrdering[extractNum] = vertex.vertexNum;
167 | 			vertex.orderPos = extractNum; 
168 | 			extractNum = extractNum + 1;
169 | 			
170 | 			//contraction part.
171 | 			contractNode(graph,vertex,extractNum-1);
172 | 		}
173 | 		return nodeOrdering;
174 | 	}
175 | 
176 | 	
177 | 	//update the neighbors of the contracted vertex that this vertex is contracted.
178 | 	private void calNeighbors(Vertex [] graph,ArrayList<Integer> inEdges, ArrayList<Integer> outEdges){
179 | 		for(int i=0;i<inEdges.size();i++){
180 | 			int temp =inEdges.get(i);
181 | 			graph[temp].delNeighbors++;
182 | 		}
183 | 
184 | 		for(int i=0;i<outEdges.size();i++){
185 | 			int temp =outEdges.get(i);
186 | 			graph[temp].delNeighbors++;
187 | 		}
188 | 	}
189 | 
190 | 
191 | 	//function to contract the node.
192 | 	private void contractNode(Vertex [] graph, Vertex vertex, int contractId){
193 | 		ArrayList<Integer> inEdges = vertex.inEdges;
194 | 		ArrayList<Long> inECost = vertex.inECost;
195 | 		ArrayList<Integer> outEdges = vertex.outEdges;
196 | 		ArrayList<Long> outECost = vertex.outECost;
197 | 		
198 | 		vertex.contracted=true;
199 | 		
200 | 		long inMax = 0;						//stores the max distance out of uncontracted inVertices of the given vertex.
201 | 		long outMax =0;						//stores the max distance out of uncontracted outVertices of the given vertex.
202 | 
203 | 		calNeighbors(graph,vertex.inEdges,vertex.outEdges);	//update the given vertex's neighbors about that the given vertex is contracted.
204 | 			
205 | 		for(int i=0; i<inECost.size();i++){
206 | 			if(graph[inEdges.get(i)].contracted){
207 | 				continue;
208 | 			}
209 | 			if(inMax<inECost.get(i)){
210 | 				inMax = inECost.get(i);
211 | 			}
212 | 		}
213 | 
214 | 		for(int i=0; i<outECost.size();i++){
215 | 			if(graph[outEdges.get(i)].contracted){
216 | 				continue;
217 | 			}
218 | 			if(outMax<outECost.get(i)){
219 | 				outMax = outECost.get(i);
220 | 			}
221 | 		}
222 | 
223 | 		long max = inMax+outMax; 				//total max distance.
224 | 		
225 | 		for(int i=0;i<inEdges.size();i++){
226 | 			int inVertex = inEdges.get(i);
227 | 			if(graph[inVertex].contracted){
228 | 				continue;
229 | 			}
230 | 			long incost = inECost.get(i);
231 | 			
232 | 			dijkstra(graph,inVertex,max,contractId,i); 	//finds the shortest distances from the inVertex to all the outVertices.
233 | 
234 | 			//this code adds shortcuts.
235 | 			for(int j=0;j<outEdges.size();j++){
236 | 				int outVertex = outEdges.get(j);
237 | 				long outcost = outECost.get(j);
238 | 				if(graph[outVertex].contracted){
239 | 					continue;
240 | 				}
241 | 				if(graph[outVertex].distance.contractId!=contractId || graph[outVertex].distance.sourceId!=i || graph[outVertex].distance.distance>incost+outcost){
242 | 					graph[inVertex].outEdges.add(outVertex);
243 | 					graph[inVertex].outECost.add(incost+outcost);
244 | 					graph[outVertex].inEdges.add(inVertex);
245 | 					graph[outVertex].inECost.add(incost+outcost);
246 | 				}
247 | 			}
248 | 		}
249 | 	}
250 | 
251 | 	
252 | 	//dijkstra function implemented.
253 | 	private void dijkstra(Vertex [] graph, int source, long maxcost, int contractId,int sourceId){
254 | 		queue = new PriorityQueue<Vertex>(graph.length,PQcomp);
255 | 		
256 | 		graph[source].distance.distance = 0;
257 | 		graph[source].distance.contractId=contractId;
258 | 		graph[source].distance.sourceId = sourceId;
259 | 		
260 | 		queue.clear();
261 | 		queue.add(graph[source]);
262 | 		
263 | 		int i=0;
264 | 		while(queue.size()!=0){
265 | 			Vertex vertex = (Vertex)queue.poll();
266 | 			if(i>3 || vertex.distance.distance > maxcost){
267 | 				return;
268 | 			}
269 | 			relaxEdges(graph,vertex.vertexNum,contractId,queue,sourceId);
270 | 		}
271 | 	}
272 | 	
273 | 	//function to relax outgoing edges. 
274 | 	private void relaxEdges(Vertex [] graph,int vertex,int contractId, PriorityQueue queue,int sourceId){
275 | 		ArrayList<Integer> vertexList = graph[vertex].outEdges;
276 | 		ArrayList<Long> costList = graph[vertex].outECost;
277 | 		
278 | 		for(int i=0;i<vertexList.size();i++){
279 | 			int temp = vertexList.get(i);
280 | 			long cost = costList.get(i);
281 | 			if(graph[temp].contracted){
282 | 				continue;
283 | 			}
284 | 			if(checkId(graph,vertex,temp) || graph[temp].distance.distance > graph[vertex].distance.distance + cost){
285 | 				graph[temp].distance.distance = graph[vertex].distance.distance + cost;
286 | 				graph[temp].distance.contractId = contractId;
287 | 				graph[temp].distance.sourceId = sourceId;
288 | 				
289 | 				queue.remove(graph[temp]);
290 | 				queue.add(graph[temp]);
291 | 			}
292 | 		}
293 | 	}
294 | 
295 | 	//compare the ids whether id of source to target is same if not then consider the target vertex distance=infinity.
296 | 	private boolean checkId(Vertex [] graph,int source,int target){
297 | 		if(graph[source].distance.contractId != graph[target].distance.contractId || graph[source].distance.sourceId != graph[target].distance.sourceId){
298 | 			return true;
299 | 		}
300 | 		return false;
301 | 	}
302 | 
303 | 	//main function of this class.
304 | 	public int [] processing(Vertex [] graph){
305 | 		computeImportance(graph);		//find initial importance by traversing all vertices.
306 | 		int [] nodeOrdering = preProcess(graph);
307 | 		return nodeOrdering;
308 | 	}
309 |     }
310 | 
311 | 
312 | 			
313 |      
314 |     //priorityQueue(min heap) for bidirectional dijkstra algorithms.(for forward search)
315 |     public static class forwComparator implements Comparator<Vertex>{
316 | 	public int compare(Vertex vertex1, Vertex vertex2){
317 | 		if(vertex1.distance.queryDist>vertex2.distance.queryDist){
318 | 			return 1;
319 | 		}
320 | 		if(vertex1.distance.queryDist<vertex2.distance.queryDist){
321 | 			return -1;
322 | 		}
323 | 		return 0;
324 | 	}
325 |     }
326 |    
327 | 
328 | 
329 |     //priorityQueue(min heap) for bidirectional dijkstra algorithms.(for backward search)
330 |     public static class revComparator implements Comparator<Vertex>{
331 | 	public int compare(Vertex vertex1, Vertex vertex2){
332 | 		if( vertex1.distance.revDistance>vertex2.distance.revDistance){
333 | 			return 1;
334 | 		}
335 | 		if(vertex1.distance.revDistance<vertex2.distance.revDistance){
336 | 			return -1;
337 | 		}
338 | 		return 0;
339 | 	}
340 |     }
341 | 
342 |     
343 | 
344 |     //class for bidirectional dijstra search.
345 |     static class BidirectionalDijkstra{
346 | 	Comparator<Vertex> forwComp = new forwComparator();
347 |     	Comparator<Vertex> revComp = new revComparator();
348 |     	PriorityQueue<Vertex> forwQ;
349 |     	PriorityQueue<Vertex> revQ;
350 | 	
351 |  	//main function that will compute distances.
352 | 	public long computeDist(Vertex [] graph, int source, int target, int queryID , int [] nodeOrdering){
353 | 		graph[source].distance.queryDist = 0;
354 | 		graph[source].distance.forwqueryId = queryID;
355 | 		graph[source].processed.forwqueryId = queryID;
356 | 
357 | 		graph[target].distance.revDistance = 0;
358 | 		graph[target].distance.revqueryId = queryID;
359 | 		graph[target].processed.revqueryId = queryID;
360 | 
361 | 		forwQ = new PriorityQueue<Vertex>(graph.length,forwComp);
362 | 		revQ = new PriorityQueue<Vertex>(graph.length,revComp);
363 | 		
364 | 		forwQ.add(graph[source]);
365 | 		revQ.add(graph[target]);
366 | 
367 | 		long estimate = Long.MAX_VALUE;
368 | 		
369 | 		while(forwQ.size()!=0 || revQ.size()!=0){
370 | 			if(forwQ.size()!=0){
371 | 				Vertex vertex1 = (Vertex)forwQ.poll();
372 | 				if(vertex1.distance.queryDist<=estimate){
373 | 					relaxEdges(graph,vertex1.vertexNum,"f",nodeOrdering,queryID);
374 | 				}
375 | 				if(vertex1.processed.revqueryId == queryID && vertex1.processed.revProcessed){
376 | 					if(vertex1.distance.queryDist + vertex1.distance.revDistance < estimate){
377 | 						estimate = vertex1.distance.queryDist + vertex1.distance.revDistance;
378 | 					}
379 | 				}
380 | 			}
381 | 			
382 | 			if(revQ.size()!=0){
383 | 				Vertex vertex2 = (Vertex)revQ.poll();
384 | 				if(vertex2.distance.revDistance <= estimate){
385 | 					relaxEdges(graph,vertex2.vertexNum,"r",nodeOrdering,queryID);
386 | 				}
387 | 				if(vertex2.processed.forwqueryId == queryID && vertex2.processed.forwProcessed){
388 | 					if(vertex2.distance.revDistance + vertex2.distance.queryDist < estimate){
389 | 						estimate = vertex2.distance.queryDist + vertex2.distance.revDistance;
390 | 					}
391 | 				}
392 | 			}
393 | 		}
394 | 
395 | 		if(estimate==Long.MAX_VALUE){
396 | 			return -1;
397 | 		}
398 | 		return estimate;
399 | 	}
400 | 
401 | 
402 | 
403 | 	//function to relax edges.(according to the direction forward or backward)
404 | 	private void relaxEdges(Vertex [] graph, int vertex,String str,int [] nodeOrdering, int queryId){
405 | 		if(str == "f"){
406 | 			ArrayList<Integer> vertexList = graph[vertex].outEdges;
407 | 			ArrayList<Long> costList = graph[vertex].outECost;
408 | 			graph[vertex].processed.forwProcessed=true;
409 | 			graph[vertex].processed.forwqueryId = queryId;
410 | 			
411 | 			for(int i=0;i<vertexList.size();i++){
412 | 				int temp = vertexList.get(i);
413 | 				long cost = costList.get(i);
414 | 				if(graph[vertex].orderPos < graph[temp].orderPos){
415 | 					if(graph[vertex].distance.forwqueryId != graph[temp].distance.forwqueryId || graph[temp].distance.queryDist > graph[vertex].distance.queryDist + cost){
416 | 						graph[temp].distance.forwqueryId = graph[vertex].distance.forwqueryId;
417 | 						graph[temp].distance.queryDist = graph[vertex].distance.queryDist + cost;
418 | 						
419 | 						forwQ.remove(graph[temp]);
420 | 						forwQ.add(graph[temp]);
421 | 					}
422 | 				}
423 | 			}
424 | 		}
425 | 		else{
426 | 			ArrayList<Integer> vertexList = graph[vertex].inEdges;
427 | 			ArrayList<Long> costList = graph[vertex].inECost;
428 | 			graph[vertex].processed.revProcessed = true;
429 | 			graph[vertex].processed.revqueryId = queryId;
430 | 			
431 | 			for(int i=0;i<vertexList.size();i++){
432 | 				int temp = vertexList.get(i);
433 | 				long cost = costList.get(i);
434 | 				
435 | 				if(graph[vertex].orderPos < graph[temp].orderPos){
436 | 					if(graph[vertex].distance.revqueryId != graph[temp].distance.revqueryId || graph[temp].distance.revDistance > graph[vertex].distance.revDistance + cost){
437 | 						graph[temp].distance.revqueryId = graph[vertex].distance.revqueryId;
438 | 						graph[temp].distance.revDistance = graph[vertex].distance.revDistance + cost;
439 | 						
440 | 						revQ.remove(graph[temp]);
441 | 						revQ.add(graph[temp]);
442 | 					}
443 | 				}
444 | 			}
445 | 		}
446 | 	}
447 | 		
448 |     }
449 | 
450 |     //main function to run the program.
451 |     public static void main(String args[]) {
452 |         Scanner in = new Scanner(System.in);
453 |         int n = in.nextInt();	//number of vertices in the graph.
454 |         int m = in.nextInt();	//number of edges in the graph.
455 | 
456 | 	Vertex vertex = new Vertex();
457 | 	Vertex [] graph = new Vertex[n];
458 | 	
459 | 	//initialize the graph.
460 | 	for(int i=0;i<n;i++){
461 | 		graph[i] = new Vertex(i);
462 | 	}
463 | 
464 | 	//get edges
465 |         for (int i = 0; i < m; i++) {
466 |             int x, y;
467 |             Long c;
468 |             x = in.nextInt()-1;
469 |             y = in.nextInt()-1;
470 |             c = in.nextLong();
471 |             
472 | 	    graph[x].outEdges.add(y);
473 | 	    graph[x].outECost.add(c);
474 | 	    graph[y].inEdges.add(x);
475 | 	    graph[y].inECost.add(c);
476 | 	}
477 | 	
478 | 	//preprocessing stage.
479 | 	PreProcess process = new PreProcess();
480 |         int [] nodeOrdering = process.processing(graph);
481 |        
482 | 	System.out.println("Ready");
483 | 	
484 | 	//acutal distance computation stage.
485 | 	BidirectionalDijkstra bd = new BidirectionalDijkstra();
486 | 
487 |         int t = in.nextInt();
488 | 
489 |         for (int i = 0; i < t; i++) {
490 |             int u, v;
491 |             u = in.nextInt()-1;
492 |             v = in.nextInt()-1;
493 |             System.out.println(bd.computeDist(graph,u,v,i,nodeOrdering));
494 |         }
495 |     }
496 | }


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 Navjinder Virdee
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Advanced-Shortest-Paths-Algorithms
 2 | Java Code for Contraction Hierarchies Algorithm, A-Star Algorithm and Bidirectional Dijkstra Algorithm. Tested and Verified Code.
 3 | 
 4 | * **Bi-Directional Dijsktra Algorithm**: Bidirectional search is a graph search algorithm that finds a shortest path from an initial vertex to a goal vertex in a directed graph. It runs two simultaneous searches: one forward from the initial state, and one backward from the goal, stopping when the two meet in the middle. The reason for this approach is that in many cases it is faster.
 5 | 
 6 |   * **Algorithm**:
 7 |     * Read the vertices and edges and create a graph using adjacency list.
 8 |     * Create a reverse graph from the input graph.
 9 |     * Start Dijkstra from source vertex in the forward graph and from target vertex in the reverse graph.
10 |     * Alternate between Dijkstra steps in forward and reverse graph.
11 |     * Stop! whwn some vertex v is processed both in forward and reverse graph.
12 |     * For all the vertices processed in the forward and reverse graph, calculate distance from source to that vertex plus vertex to target
13 |     * Print the min distance from the above step.
14 | 
15 | * **A-Star Algorithm**: In computer science, A* (pronounced as "A star") is a computer algorithm that is widely used in pathfinding and graph traversal, the process of plotting an efficiently directed path between multiple points, called nodes. It enjoys widespread use due to its performance and accuracy. However, in practical travel-routing systems, it is generally outperformed by algorithms which can pre-process the graph to attain better performance, although other work has found A* to be superior to other approaches.
16 | 
17 |   What A* Search Algorithm does is that at each step it picks the node according to a value-‘f’ which is a parameter equal to the sum of     two other parameters – ‘g’ and ‘h’. At each step it picks the node/cell having the lowest ‘f’, and process that node/cell.
18 | 
19 |   We define ‘g’ and ‘h’ as simply as possible below
20 | 
21 |   g = the minimum distance to move from the starting point to a given node in the graph.
22 |   h = It is nothing but the eulidean distance between the current node/vertex and the target vertex. Other heuristics can also be used.
23 |   
24 | * **Contraction Hierarchies Algorithm**:  In applied mathematics, the method of contraction hierarchies is a technique to speed up shortest-path routing by first creating precomputed "contracted" versions of the connection graph. It can be regarded as a special case of "highway-node routing".
25 | 
26 |   Contraction hierarchies can be used to generate shortest-path routes much more efficiently than Dijkstra's algorithm or previous           highway-node routing approaches, and is used in many advanced routing techniques.It is publicly available in open source software to       calculate routes from one place to another.
27 |   
28 |     * **Algorithm**:
29 |       * Read the input vertices and edges and create the graph.
30 |       * Pre-process the graph.
31 |       * Use modified Bidirectional Dijkstra to find shortest distance between source and the target.
32 |       
33 |       **Pre-Processing**:
34 |       
35 |         **Order By Importance**: Introduce a measure of importance and contract the least importance vertices. Importance can also               change after we contract the vertex i.e importance of adjacent vertices may change due to contraction of this vertex.
36 |       
37 |       **Steps**:
38 |         * Keep all the vertices in a priority queue by decreasing importance.
39 |         * On each iteration, extract the least important vertex.
40 |         * Recompute its importance because it could have changed because of the contraction of other nodes.
41 |         * If its still minimum contract the node.
42 |         * Otherwise, put it back into the priroity queue.
43 |         * Store these contracted vertices in increasing order i.e vertex contracted first comes first and contracted last comes at end.
44 |         
45 |       **Importance Criteria**:
46 |         * Edge Difference : number of added shortcuts - number of incoming edges - number of outgoing egdes.
47 |         * Contracted Neighbors : Want to spread the contracted vertices across the graph. Contract the node with small no. of contracted           neighbors.
48 |         * Shortcut Cover: Number of neighbors w of v such that we have to shortcut to or from after contracting v.
49 |         
50 |       **Modified Bidirectional Dijkstra**:
51 |         * Bidirectional Dijkstra will use only upward edges i.e edges going from vertices contracted first to vertices contracted later.
52 |         * Don't stop when some node was processed in both forward and backward searches.
53 |         * Stop when the processed node's distance is already farther than the target vertex. i.e keep on processing other nodes until             there are no more nodes to process both in forward search as well as backward search.
54 | 


--------------------------------------------------------------------------------