├── .gitignore
├── LICENSE
└── src
    ├── BreadthFirstSearch.java
    ├── DepthFirstSearch.java
    ├── DijkstraShortestPath.java
    ├── Graph.java
    ├── KruskalMST.java
    ├── PrimMST.java
    └── Vertex.java


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled class file
 2 | *.class
 3 | 
 4 | # Log file
 5 | *.log
 6 | 
 7 | # BlueJ files
 8 | *.ctxt
 9 | 
10 | # Mobile Tools for Java (J2ME)
11 | .mtj.tmp/
12 | 
13 | # Package Files #
14 | *.jar
15 | *.war
16 | *.ear
17 | *.zip
18 | *.tar.gz
19 | *.rar
20 | 
21 | # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
22 | hs_err_pid*
23 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 Keval Morabia
 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 | 


--------------------------------------------------------------------------------
/src/BreadthFirstSearch.java:
--------------------------------------------------------------------------------
 1 | import java.util.LinkedList;
 2 | 
 3 | public class BreadthFirstSearch extends Graph {
 4 | 	public BreadthFirstSearch(int v) {
 5 | 		super(v);
 6 | 	}
 7 | 
 8 | 	void BFS(int start){
 9 | 		for(Vertex v: vertex){
10 | 			v.color=0;
11 | 			v.distance=-1;//if after BFS, distance=-1 --> unreachable
12 | 			v.parent=null;
13 | 		}
14 | 		LinkedList<Vertex> queue = new LinkedList<>();
15 | 		vertex[start].color=1;
16 | 		vertex[start].distance=0;
17 | 		queue.add(vertex[start]);
18 | 		while(!queue.isEmpty()){
19 | 			Vertex u = queue.removeFirst();
20 | 			for(Vertex v : u.adj){
21 | 				if(v.color==0){
22 | 					v.color=1;
23 | 					v.distance=u.distance+1;
24 | 					v.parent=u;
25 | 					queue.add(v);
26 | 				}
27 | 			}
28 | 			u.color=2;
29 | 		}
30 | 	}
31 | 	
32 | 	void printPath(int start, int end){
33 | 		System.out.print("Path from "+start+" to "+end+": ");
34 | 		BFS(start);
35 | 		print(start, end);
36 | 		System.out.println();
37 | 	}
38 | 	
39 | 	void print(int start, int end){
40 | 		if(end==start)
41 | 			System.out.print(start+" ");
42 | 		else if(vertex[end].parent==null)
43 | 			System.out.println("No path from "+start+" to "+end+" exists.");
44 | 		else {
45 | 			print(start,vertex[end].parent.data);
46 | 			System.out.print(end+" ")	;
47 | 		}
48 | 	}
49 | 	
50 | 	public static void main(String[] args){
51 | 		BreadthFirstSearch g = new BreadthFirstSearch(5);
52 | 		g.addEdge(0, 1);
53 | 		g.addEdge(1, 2);
54 | 		g.addEdge(2, 0);
55 | 		g.addEdge(3, 3);
56 | 		g.addEdge(4, 2);
57 | 
58 | 		g.printPath(1, 4);
59 | 	}
60 | }
61 | 


--------------------------------------------------------------------------------
/src/DepthFirstSearch.java:
--------------------------------------------------------------------------------
 1 | public class DepthFirstSearch extends Graph{
 2 | 	int time;
 3 | 	
 4 | 	public DepthFirstSearch(int v) {
 5 | 		super(v);
 6 | 		time=0;
 7 | 	}
 8 | 	
 9 | 	void DFS(){
10 | 		time=0;
11 | 	    for(int i=0;i<v;i++){
12 | 	        if(vertex[i].color==0)
13 | 	            DFSVisit(i);
14 | 	    }
15 | 	}
16 | 	
17 | 	void DFSVisit(int u){
18 | 		time++;
19 | 		vertex[u].discoveryTime=time;
20 | 		vertex[u].color=1;
21 | 		for(Vertex v: vertex[u].adj){
22 | 			if(v.color==0){
23 | 				v.parent=vertex[u];
24 | 				DFSVisit(v.data);
25 | 			}
26 | 		}
27 | 		time++;
28 | 		vertex[u].finishTime=time;
29 | 		vertex[u].color=2;
30 | 	}
31 | 	
32 | 	void printTimes(){
33 | 		for(Vertex v: vertex){
34 | 			System.out.printf("Vertex: %2d start:%2d finish:%2d\n",v.data,
35 | 					vertex[v.data].discoveryTime, vertex[v.data].finishTime);
36 | 		}
37 | 	}
38 | 	
39 | 	public static void main(String[] args){
40 | 		DepthFirstSearch g = new DepthFirstSearch(5);
41 | 		g.addEdge(0, 1);
42 | 		g.addEdge(1, 2);
43 | 		g.addEdge(2, 0);
44 | 		g.addEdge(3, 3);
45 | 		g.addEdge(4, 2);
46 | 		g.DFS();
47 | 		g.printTimes();
48 | 		
49 | 	}
50 | 
51 | }
52 | 


--------------------------------------------------------------------------------
/src/DijkstraShortestPath.java:
--------------------------------------------------------------------------------
 1 | import java.util.Scanner;
 2 | 
 3 | public class DijkstraShortestPath extends Graph{
 4 | 	int e;//no of edges
 5 | 	int[][] weight;
 6 | 	
 7 | 	public DijkstraShortestPath(int v, int e){
 8 | 		super(v);
 9 | 		weight = new int[v+1][v+1];
10 | 	}
11 | 	
12 | 	void relax(int u, int v, int w){
13 | 		if(vertex[v].distance > vertex[u].distance+w){
14 | 			vertex[v].distance = vertex[u].distance+w;
15 | 			vertex[v].parent = vertex[u];
16 | 		}
17 | 	}
18 | 	
19 | 	void dijkstra(int start){
20 | 		initialize();
21 | 		vertex[start].extracted=true;
22 | 		vertex[start].distance = 0;
23 | 		int u = start;
24 | 		while(u!=-1){
25 | 			for(Vertex ver : vertex[u].adj){
26 | 				relax(u,ver.data,weight[u][ver.data]);
27 | 			}
28 | 			u = extractMin();
29 | 		}
30 | 				
31 | 	}
32 | 	
33 | 	void initialize(){
34 | 		for(int i = 0; i<v; i++){
35 | 			vertex[i].distance = Integer.MAX_VALUE;
36 | 		}
37 | 	}
38 | 	
39 | 	void addEdge(int u, int v, int w){//directed
40 | 		vertex[u].adj.add(vertex[v]);
41 | 		weight[u][v] = w;
42 | 	}
43 | 	
44 | 	int extractMin(){
45 | 		int index = -1;
46 | 		int min = Integer.MAX_VALUE;
47 | 		for(int i = 0; i<v; i++){
48 | 			if(!vertex[i].extracted && vertex[i].distance<min){
49 | 				index = i;
50 | 				min = vertex[i].distance;
51 | 			}
52 | 		}
53 | 		if(index!=-1)
54 | 			vertex[index].extracted = true;
55 | 		return index;
56 | 	}
57 | 	
58 | 	public static void main(String[] args){
59 | 		Scanner sc = new Scanner(System.in);
60 | 		int n = sc.nextInt();//no vertex
61 | 		int m = sc.nextInt();//no of edges
62 | 		DijkstraShortestPath g = new DijkstraShortestPath(n,m);
63 | 		
64 | 		for(int i = 0; i<m; i++){
65 | 			g.addEdge(sc.nextInt(), sc.nextInt(), sc.nextInt());
66 | 		}
67 | 		
68 | 		g.dijkstra(0);
69 | 		for(int i = 0; i<g.v; i++)
70 | 			System.out.println("Vertex: "+i+" Distance: "+g.vertex[i].distance);
71 | 		sc.close();
72 | 	}
73 | }
74 | /*
75 | SAMPLE CASE
76 | 5 9
77 | 0 1 10
78 | 0 2 3
79 | 1 2 1
80 | 2 1 4
81 | 1 3 2
82 | 2 3 8
83 | 2 4 2
84 | 3 4 7
85 | 4 3 9
86 |  */ 
87 | 


--------------------------------------------------------------------------------
/src/Graph.java:
--------------------------------------------------------------------------------
 1 | import java.util.LinkedList;
 2 | 
 3 | public class Graph {//undirected graph
 4 | 	int v;//no of vertices
 5 | 	Vertex[] vertex;
 6 | 	
 7 | 	public Graph(int v){
 8 | 		this.v=v;
 9 | 		vertex = new Vertex[v];
10 | 		for(int i = 0; i<v; i++){
11 | 			vertex[i] = new Vertex(i);
12 | 		}
13 | 	}
14 | 	
15 | 	void addEdge(int a, int b){
16 | 		vertex[a].adj.add(vertex[b]);
17 | 		if(a!=b)//otherwise 2 times added
18 | 			vertex[b].adj.add(vertex[a]);//remove this line for directed graph
19 | 	}
20 | 	
21 | 	void printList(LinkedList<Vertex> l){
22 | 		for(Vertex v: l){
23 | 			System.out.print(v.data+" ");
24 | 		}
25 | 		System.out.println();
26 | 	}
27 | 	
28 | 	void printAdjacencyList(){
29 | 		for(Vertex v: vertex){
30 | 			System.out.print("Vertex "+v.data+": ");
31 | 			printList(v.adj);
32 | 		}
33 | 	}
34 | 	
35 | 	public static void main(String[] args) {
36 | 		Graph g = new Graph(5);
37 | 		g.addEdge(0, 1);
38 | 		g.addEdge(1, 2);
39 | 		g.addEdge(2, 0);
40 | 		g.addEdge(3, 3);
41 | 		g.addEdge(4, 2);
42 | 		g.printAdjacencyList();
43 | 	}
44 | 
45 | }
46 | 


--------------------------------------------------------------------------------
/src/KruskalMST.java:
--------------------------------------------------------------------------------
 1 | import java.util.Arrays;
 2 | import java.util.Comparator;
 3 | import java.util.Scanner;
 4 | 
 5 | class Checker implements Comparator<int[]>{
 6 | 	public int compare(int[] o1, int[] o2) {
 7 | 		return Integer.compare(o1[2], o2[2]);
 8 | 	}
 9 | }
10 | 
11 | public class KruskalMST extends Graph{
12 | 	int cost;
13 | 	boolean cycle;
14 | 
15 | 	public KruskalMST(int v) {
16 | 		super(v);
17 | 		cost = 0;
18 | 		cycle = false;
19 | 	}
20 | 	
21 | 	void Kruskal(int[][] edges){
22 | 		for(int i = 0; i<edges.length; i++){
23 | 			int a = edges[i][0], b = edges[i][1], w = edges[i][2];
24 | 			if(a==b)	continue;//loop
25 | 			addEdge(a, b);
26 | 			if(!isCycle()){
27 | 				System.out.println(a+" "+b+" "+w+" added");
28 | 				cost+=w;
29 | 			}else{
30 | 				vertex[a].adj.removeLast();
31 | 				vertex[b].adj.removeLast();
32 | 			}
33 | 		}
34 | 		System.out.println("Cost: "+cost);
35 | 	}
36 | 	
37 | 	void reset(){
38 | 		for(int i = 0; i<v; i++)
39 | 			vertex[i].color = 0;
40 | 		cycle = false;
41 | 	}
42 | 	
43 | 	boolean isCycle(){
44 | 		reset();
45 | 		for(int i=0;i<v && !cycle;i++){
46 | 	        if(vertex[i].color==0)
47 | 	            DFSVisit(i);
48 | 	    }
49 | 		return cycle;
50 | 	}
51 | 	
52 | 	void DFSVisit(int u){
53 | 		vertex[u].color=1;
54 | 		for(Vertex v: vertex[u].adj){
55 | 			if(cycle)	break;
56 | 			if(v.color==2){//cycle
57 | 				cycle = true;
58 | 				return;
59 | 			}
60 | 			if(v.color==0){
61 | 				DFSVisit(v.data);
62 | 			}
63 | 		}
64 | 		vertex[u].color=2;
65 | 	}
66 | 	
67 | 	public static void main(String[] args){
68 | 		Scanner sc = new Scanner(System.in);
69 | 		int v = sc.nextInt();
70 | 		int e = sc.nextInt();
71 | 		int[][] edges = new int[e][3];
72 | 		//edge from a[0] to a[1] with weight a[2]
73 | 		for(int i = 0; i<e; i++){
74 | 			int a = sc.nextInt(), b = sc.nextInt(), w = sc.nextInt();
75 | 			edges[i][0] = a;
76 | 			edges[i][1] = b;
77 | 			edges[i][2] = w;
78 | 		}
79 | 		Arrays.sort(edges,new Checker());
80 | 		KruskalMST g = new KruskalMST(v);
81 | 		g.Kruskal(edges);
82 | 		sc.close();
83 | 	}
84 | }
85 | /*
86 | SAMPLE CASE
87 | 5 8
88 | 0 1 1
89 | 0 2 4
90 | 0 4 2
91 | 2 4 3
92 | 1 4 3
93 | 3 1 3
94 | 3 2 1
95 | 3 4 2
96 | */
97 | 


--------------------------------------------------------------------------------
/src/PrimMST.java:
--------------------------------------------------------------------------------
 1 | import java.util.Scanner;
 2 | 
 3 | public class PrimMST extends Graph{
 4 | 	int cost;
 5 | 	int[] key;
 6 | 	int[] included;
 7 | 
 8 | 	public PrimMST(int v) {
 9 | 		super(v);
10 | 		cost = 0;
11 | 		key = new int[v];
12 | 		for(int i = 0; i<v; i++)	key[i] = Integer.MAX_VALUE;
13 | 		included = new int[v];
14 | 	}
15 | 	
16 | 	int extractMin(){
17 | 		int min=Integer.MAX_VALUE;
18 | 		int index=-1;
19 | 		for(int i=0;i<v;i++){
20 | 			if(included[i]==0 && key[i]<min){
21 | 				min = key[i];
22 | 				index=i;
23 | 			}
24 | 		}
25 | 		return index;
26 | 	}
27 | 	
28 | 	void Prim(int[][] weight, int start){
29 | 		key[start]=0;
30 | 		vertex[start].parent=null;
31 | 		int u = extractMin();
32 | 		while(u!=-1){
33 | 			cost+=key[u];
34 | 			for(Vertex ver:vertex[u].adj){
35 | 				if(included[ver.data]==0 && weight[u][ver.data]<key[ver.data]){
36 | 					ver.parent=vertex[u];
37 | 					key[ver.data]=weight[u][ver.data];
38 | 				}
39 | 			}
40 | 			included[u]=1;
41 | 			u=extractMin();
42 | 		}
43 | 		System.out.println("Cost: "+cost);
44 | 	}
45 | 	
46 | 	public static void main(String[] args){
47 | 		Scanner sc = new Scanner(System.in);
48 | 		int v = sc.nextInt();
49 | 		int e = sc.nextInt();
50 | 		int[][] weight = new int[v][v];
51 | 		PrimMST g = new PrimMST(v);
52 | 		for(int i = 0; i<e; i++){
53 | 			int a = sc.nextInt(), b = sc.nextInt(), w = sc.nextInt();
54 | 			weight[a][b]=w;
55 | 			weight[b][a]=w;
56 | 			g.addEdge(a, b);
57 | 		}
58 | 		int start = 0;
59 | 		g.Prim(weight,start);
60 | 		sc.close();
61 | 	}
62 | }
63 | 
64 | /*
65 | SAMPLE CASE
66 | 5 8
67 | 0 1 1
68 | 0 2 4
69 | 0 4 2
70 | 2 4 3
71 | 1 4 3
72 | 3 1 3
73 | 3 2 1
74 | 3 4 2
75 | */
76 | 


--------------------------------------------------------------------------------
/src/Vertex.java:
--------------------------------------------------------------------------------
 1 | import java.util.LinkedList;
 2 | 
 3 | public class Vertex {
 4 | 	LinkedList<Vertex> adj;
 5 | 	int data;
 6 | 	int color;//0=white, 1=gray, 2=black
 7 | 	int distance;//from start vertex
 8 | 	Vertex parent;
 9 | 	int discoveryTime;
10 | 	int finishTime;
11 | 	boolean extracted;
12 | 	
13 | 	public Vertex(int data){
14 | 		this.data=data;
15 | 		color=0;
16 | 		distance=-1;
17 | 		parent=null;
18 | 		adj = new LinkedList<>();
19 | 		discoveryTime=0;
20 | 		finishTime=0;
21 | 	}
22 | }
23 | 


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