Dijkstra's Algorithm with Priority Queue

Algorithms/Graph Algorithms/Dijkstra_priority_queue.cpp

@@ -0,0 +1,85 @@
+// Program to find Dijkstra's shortest path using priority_queue with vectors 
+#include<bits/stdc++.h> 
+using namespace std; 
+# define INF 0x3f3f3f3f 
+
+// iPair ==> Integer Pair 
+typedef pair<int, int> iPair; 
+
+// To add an edge 
+void addEdge(vector <pair<int, int> > adj[], int u, int v, int wt) 
+{ 
+	adj[u].push_back(make_pair(v, wt)); 
+	adj[v].push_back(make_pair(u, wt)); 
+} 
+
+
+// Prints shortest paths from src to all other vertices 
+void shortestPath(vector<pair<int,int> > adj[], int V, int src) 
+{ 
+	// Create a priority queue to store vertices that are being preprocessed.  
+	priority_queue< iPair, vector <iPair> , greater<iPair> > pq; 
+
+	// Create a vector for distances and initialize all distances as infinite (INF) 
+	vector<int> dist(V, INF); 
+
+	// Insert source itself in priority queue and initialize its distance as 0. 
+	pq.push(make_pair(0, src)); 
+	dist[src] = 0; 
+
+	// Looping till priority queue becomes empty 
+	while (!pq.empty()) 
+	{ 
+		// The first vertex in pair is the minimum distance vertex, extract it from priority queue. Vertex label is stored in second of pair. 
+		int u = pq.top().second; 
+		pq.pop(); 
+
+		// Get all adjacent of u. 
+		for (auto x : adj[u]) 
+		{ 
+			// Get vertex label and weight of current adjacent of u. 
+			int v = x.first; 
+			int weight = x.second; 
+
+			// If there is shorted path to v through u. 
+			if (dist[v] > dist[u] + weight) 
+			{ 
+				// Updating distance of v 
+				dist[v] = dist[u] + weight; 
+				pq.push(make_pair(dist[v], v)); 
+			} 
+		} 
+	} 
+
+	// Print shortest distances stored in dist[] 
+	printf("Vertex          Distance from Source\n"); 
+	for (int i = 0; i < V; ++i) 
+		printf("%d \t\t %d\n", i, dist[i]); 
+} 
+
+// Driver program
+int main() 
+{ 
+	int V = 9; 
+	vector<iPair > adj[V]; 
+
+	// making above shown graph 
+	addEdge(adj, 0, 1, 4); 
+	addEdge(adj, 0, 7, 8); 
+	addEdge(adj, 1, 2, 8); 
+	addEdge(adj, 1, 7, 11); 
+	addEdge(adj, 2, 3, 7); 
+	addEdge(adj, 2, 8, 2); 
+	addEdge(adj, 2, 5, 4); 
+	addEdge(adj, 3, 4, 9); 
+	addEdge(adj, 3, 5, 14); 
+	addEdge(adj, 4, 5, 10); 
+	addEdge(adj, 5, 6, 2); 
+	addEdge(adj, 6, 7, 1); 
+	addEdge(adj, 6, 8, 6); 
+	addEdge(adj, 7, 8, 7); 
+
+	shortestPath(adj, V, 0); 
+
+	return 0; 
+} 

Algorithms/Graph Algorithms/KruskalMST.cpp

@@ -0,0 +1,165 @@
+// C++ program for Kruskal's algorithm to find MST of a given connected, undirected and weighted graph.
+
+#include <bits/stdc++.h> 
+using namespace std; 
+
+// A structure to represent a weighted edge in graph 
+class Edge 
+{ 
+	public: 
+	int src, dest, weight; 
+}; 
+
+//A structure to represent a connected, undirected and weighted graph 
+class Graph 
+{ 
+	public: 
+	// V-> Number of vertices, E-> Number of edges 
+	int V, E; 
+
+	Edge* edge; 
+}; 
+
+// Creating a graph with V vertices and E edges 
+Graph* createGraph(int V, int E) 
+{ 
+	Graph* graph = new Graph; 
+	graph->V = V; 
+	graph->E = E; 
+
+	graph->edge = new Edge[E]; 
+
+	return graph; 
+} 
+
+// A structure to represent a subset for union-find 
+class subset 
+{ 
+	public: 
+	int parent; 
+	int rank; 
+}; 
+
+// A utility function to find set of an element i 
+int find(subset subsets[], int i) 
+{ 
+// find root and make root as parent of i 
+	if (subsets[i].parent != i) 
+		subsets[i].parent = find(subsets, subsets[i].parent); 
+
+	return subsets[i].parent; 
+} 
+
+// A function that does union of two sets of x and y 
+void Union(subset subsets[], int x, int y) 
+{ 
+	int xroot = find(subsets, x); 
+	int yroot = find(subsets, y); 
+
+// Attach smaller rank tree under root of high rank tree (Union by Rank) 
+	if (subsets[xroot].rank < subsets[yroot].rank) 
+		subsets[xroot].parent = yroot; 
+	else if (subsets[xroot].rank > subsets[yroot].rank) 
+		subsets[yroot].parent = xroot; 
+
+// If ranks are same, then make one as root and increment its rank by one 
+	else
+	{ 
+		subsets[yroot].parent = xroot; 
+		subsets[xroot].rank++; 
+	} 
+} 
+
+// Compare two edges according to their weights. Used in qsort() for sorting an array of edges 
+int myComp(const void* a, const void* b) 
+{ 
+	Edge* a1 = (Edge*)a; 
+	Edge* b1 = (Edge*)b; 
+	return a1->weight > b1->weight; 
+} 
+
+// The main function to construct MST using Kruskal's algorithm 
+void KruskalMST(Graph* graph) 
+{ 
+	int V = graph->V;
+    // Tnis will store the resultant MST 
+	Edge result[V];
+    // An index variable, used for result[]  
+	int e = 0; 
+    // An index variable, used for sorted edges 
+	int i = 0;  
+
+	// Step 1: Sort all the edges in non-decreasing order of their weight.
+	qsort(graph->edge, graph->E, sizeof(graph->edge[0]), myComp); 
+
+	// Allocate memory for creating V ssubsets 
+	subset *subsets = new subset[( V * sizeof(subset) )]; 
+
+	// Create V subsets with single elements 
+	for (int v = 0; v < V; ++v) 
+	{ 
+		subsets[v].parent = v; 
+		subsets[v].rank = 0; 
+	} 
+
+	// Number of edges to be taken is equal to V-1 
+	while (e < V - 1 && i < graph->E) 
+	{ 
+	// Step 2: Pick the smallest edge. And increment the index for next iteration 
+		Edge next_edge = graph->edge[i++]; 
+
+		int x = find(subsets, next_edge.src); 
+		int y = find(subsets, next_edge.dest); 
+
+		if (x != y) 
+		{ 
+			result[e++] = next_edge; 
+			Union(subsets, x, y); 
+		} 
+	// Else discard the next_edge 
+	} 
+
+	// print the contents of result[] to display the built MST 
+	cout<<"Following are the edges in the constructed MST\n"; 
+	for (i = 0; i < e; ++i) 
+		cout<<result[i].src<<" -- "<<result[i].dest<<" == "<<result[i].weight<<endl; 
+	return; 
+} 
+
+// Driver code 
+int main() 
+{ 
+	int V = 4; // Number of vertices in graph 
+	int E = 5; // Number of edges in graph 
+	Graph* graph = createGraph(V, E); 
+
+
+	// add edge 0-1 
+	graph->edge[0].src = 0; 
+	graph->edge[0].dest = 1; 
+	graph->edge[0].weight = 10; 
+
+	// add edge 0-2 
+	graph->edge[1].src = 0; 
+	graph->edge[1].dest = 2; 
+	graph->edge[1].weight = 6; 
+
+	// add edge 0-3 
+	graph->edge[2].src = 0; 
+	graph->edge[2].dest = 3; 
+	graph->edge[2].weight = 5; 
+
+	// add edge 1-3 
+	graph->edge[3].src = 1; 
+	graph->edge[3].dest = 3; 
+	graph->edge[3].weight = 15; 
+
+	// add edge 2-3 
+	graph->edge[4].src = 2; 
+	graph->edge[4].dest = 3; 
+	graph->edge[4].weight = 4; 
+
+	KruskalMST(graph); 
+
+	return 0; 
+}