Make comments concise and refactor some code

Author: ivmarkp

Detect_Cycle/directed.cc

@@ -1,13 +1,14 @@
-/** Given a directed graph, check whether the graph contains a cycle or not.
+/** 
+ * Given a directed graph, check whether the graph contains a cycle or not.
  *
- *	Note: There is a cycle in a graph only if there is a back edge present in
- *	it. A back edge is an edge that is from a node to itself (self-loop) or
- *	one of its ancestor i.e. an edge to the next node will form a cycle, only
- *	if that node is an ancestor of the present node.
+ * Note: There is a cycle in a graph only if there is a back edge present in
+ * it. A back edge is an edge that is from a node to itself (self-loop) or
+ * one of its ancestor i.e. an edge to the next node will form a cycle, only
+ * if that node is an ancestor of the present node.
  *
- *	To detect a back edge, we can keep track of vertices currently in recursion
- *	stack of function for DFS traversal. If we reach a vertex that is already in
- *	the recursion stack, then there is a cycle in the tree.
+ * To detect a back edge, we can keep track of vertices currently in recursion
+ * stack of function for DFS traversal. If we reach a vertex that is already in
+ * the recursion stack, then there is a cycle in the tree.
  */
 #include <bits/stdc++.h>
 using namespace std;
@@ -83,4 +84,4 @@ int main() {
 
 	return 0;
 }
-// Time Complexity: Same as DFS i.e. O(V + E).
+// Time Complexity: Same as DFS i.e. O(V + E).

Detect_Cycle/directed_color.cc

@@ -1,7 +1,8 @@
-/** Given a directed graph, check whether the graph contains a cycle or not.
+/** 
+ * Given a directed graph, check whether the graph contains a cycle or not.
  *
- *	Note: The idea is to do DFS of given graph and while doing traversal, assign
- *	one of the three colors (white, gray, black) to every vertex.
+ * Note: The idea is to do DFS of given graph and while doing traversal, assign
+ * one of the three colors (white, gray, black) to every vertex.
  */
 #include <bits/stdc++.h>
 using namespace std;
@@ -72,4 +73,4 @@ int main() {
 
 	return 0;
 }
-// Time Complexity: Same as DFS i.e. O(V + E).
+// Time Complexity: Same as DFS i.e. O(V + E).

Detect_Cycle/undirected.cc

@@ -1,11 +1,13 @@
-/** Given a undirected graph, check whether the graph contains a cycle or not.
+/** 
+ * Given a undirected graph, check whether the graph contains a cycle or not.
  *
- *	Note: Like directed graphs, we can use DFS to detect cycle in an undirected graph.
- *	For every visited vertex ‘v’, if there is an adjacent ‘u’ such that u has
- *	already been visited and u is not parent of v, then there is a cycle in graph.
- *	
- *	The assumption of this approach is that there are no parallel edges between any
- *	two vertices.
+ * Note: Like directed graphs, we can use DFS to detect cycle in an undirected
+ * graph. For every visited vertex ‘v’, if there is an adjacent ‘u’ such that
+ * u has already been visited and u is not parent of v, then there is a cycle
+ * in graph.
+ *
+ * The assumption of this approach is that there are no parallel edges between
+ * any two vertices.
  */
 #include <bits/stdc++.h>
 using namespace std;
@@ -74,4 +76,4 @@ int main() {
 
 	return 0;
 }
-// Time Complexity: Same as DFS i.e. O(V + E).
+// Time Complexity: Same as DFS i.e. O(V + E).

Min_Spanning_Tree/prim_list.cc

@@ -1,17 +1,15 @@
-/** Given an undirected, connected and weighted graph, find MST of the graphs
- *	using Prim’s algorithm.
+/**
+ * Prim’s MST algorithm for adjacency list representation of undirected,
+ * connected and weighted graphs.
  */
 #include <bits/stdc++.h>
 using namespace std;
 
-typedef pair<int, int> int_pair;
-
 class graph {
     int nv;
     // A weighted graph, so need to store a vertex and
     // weight pair for every single vertex.
-    vector<vector<int_pair>> adj;
-
+    vector<vector<pair<int, int>>> adj;
     public:
         graph(int num) : nv(num), adj(num) {}
     	void addEdge(int u, int v, int wt) {
@@ -24,42 +22,44 @@ class graph {
 
 void graph::prims(int s) {
 	// Create a min-heap using priority_queue container. priority_queue
-	// container class provides a constructor that requires two extra
-	// arguments to make it a min heap i.e. vector<...> & greater<...>.
-	priority_queue<int_pair, vector<int_pair>, greater<int_pair>> heap;
-	
-	// A vector for weight and initialise as INT_MAX.
-	vector<int> weight(nv, INT_MAX);
+	// container constructor requires two extra arguments to make it a
+	// min heap i.e. vector<...> & greater<...>.
+	priority_queue<pair<int, int>, vector<pair<int, int>>,
+				   greater<pair<int, int>> > heap;
 
+	// A vector to store weights of vertices with all weights
+	// intialised as INT_MAX.
+	vector<int> weight(nv, INT_MAX);
 	// Another vector to store the parent of vertices.
 	vector<int> parent(nv, -1);
-
 	// A vector to keep track of vertices included in MST.
 	vector<bool> mst(nv, false);
-	
+
 	// Set weight of source vertex as zero.
 	weight[s] = 0;
+
 	// Insert source vertex in the heap.
 	heap.push(make_pair(weight[s], s));
-	
+
 	while (!heap.empty()) {
 		// Extract the min vertex based on their associated weights.
 		int u = heap.top().second;
 		heap.pop();
-		
+
 		// Include extracted vertex in mst.
 		mst[u] = true;
-		vector<pair<int, int>>::iterator i;
-		for (i = adj[u].begin(); i != adj[u].end(); ++i) {
-			// Get the vertex label and the weight
+
+		for (auto i = adj[u].begin(); i != adj[u].end(); ++i) {
+			// Get the vertex label and the weights
 			int v = (*i).first;
 			int v_wt = (*i).second;
-			
+
 			// If v is not in mst and edge (u, v) weight < weight of v
 			if (mst[v] == false && v_wt < weight[v]) {
 				// Update weight of v
 				weight[v] = v_wt;
 				heap.push(make_pair(weight[v], v));
+				// Update parent of v
 				parent[v] = u;
 			}
 		}
@@ -72,14 +72,15 @@ void graph::prims(int s) {
 
 int main() {
 	graph g(5);
-	
+
 	g.addEdge(0, 1, 1);
     g.addEdge(0, 2, 3);
     g.addEdge(1, 2, 7);
     g.addEdge(2, 3, 4);
     g.addEdge(3, 4, 6);
 
 	g.prims(0);
-	
+
 	return 0;
 }
+// Time complexity : O(E*Log V))

Min_Spanning_Tree/prim_matrix.cc

@@ -0,0 +1,71 @@
+/**
+ * Prim’s MST algorithm for adjacency matrix representation of undirected,
+ * connected and weighted graphs.
+ */
+#include <bits/stdc++.h>
+using namespace std;
+
+int findMinKeyVertex(vector<int>& k, vector<bool>& mst, int v) {
+	int min = INT_MAX, index;
+	for (int i = 0; i < v; i++) {
+		if (mst[i] == false && k[i] < min) {
+			min = k[i];
+			index = i;
+		}
+	}
+	return index;
+}
+
+void primsMST(vector<vector<int>>& graph, int v) {
+	// A vector to store key values of all vertices with all keys
+	// intialised as INT_MAX.
+	vector<int> key(v, INT_MAX);
+
+	// A boolean vector to represent set of vertices included in MST.
+	vector<bool> InMST(v, false);
+
+	// A vector to store indices of parents in MST.
+	vector<int> parent(v);
+
+	// Starting from vertex 0 so set its key as 0 and as it is the root
+	// of MST so set its parent as -1.
+	key[0] = 0;
+	parent[0] = -1;
+
+	for (int i = 0; i < v; i++) {
+		// Find the min key vertex from the set of vertices
+		// not included in MST.
+		int u = findMinKeyVertex(key, InMST, v);
+
+		// Mark min key vertex as included in MST.
+		InMST[u] = true;
+
+		// Update keys and parents of the adjacent vertices.
+		for (int j = 0; j < v; j++) {
+			if (graph[u][j] && InMST[j] == false
+				&& graph[u][j] < key[j])
+				parent[j] = u, key[j] = graph[u][j];
+		}
+	}
+
+	// Print the edges of MST.
+	for (int i = 1; i < v; i++)
+		cout << parent[i] << " - " << i << endl;
+}
+
+int main() {
+	int nv;
+	cin >> nv;
+
+	vector<vector<int>> graph(nv, vector<int>(nv));
+
+	for (int i = 0; i < nv; i++)
+		for (int j = 0; j < nv; j++)
+			cin >> graph[i][j];
+
+	primsMST(graph, nv);
+
+	return 0;
+}
+// Time Complexity : O(V^2). With adjacency list representation, the time
+// complexity can be reduced to O(E*logV) with the help of a binary heap.

Representation/adjacency_list.cc

@@ -1,34 +1,30 @@
-/** Implementation of adjacency list representation of a graph.
- *  E.g. Consider the following graph
- *	A --- B
- *	| \   |
- *	|  \  |
- *	|	\ |
- *	D --- C
+/**
+ * Adjacency list representation of a graph.
  *
- *  Adjacency matrix for this (undirected) graph is:
- *	 0 -> 1 -> 2 -> 3
- *	 1 -> 0 -> 2
- *	 2 -> 0 -> 1 -> 3
- *	 3 -> 0 -> 2
+ * E.g. Consider the following graph
+ * A --- B
+ * | \   |
+ * |  \  |
+ * |   \ |
+ * D --- C
+ *
+ * Adjacency matrix for this (undirected) graph is:
+ * 0 -> 1 -> 2 -> 3
+ * 1 -> 0 -> 2
+ * 2 -> 0 -> 1 -> 3
+ * 3 -> 0 -> 2
  */
 #include <bits/stdc++.h>
 using namespace std;
 
 class graph {
 	// No. of vertices and edges
-	int v;
-	int e;
-	// A pointer to a vector(or array) of lists
+	int v, e;
+	// A vector(or array) of lists
 	vector<list<int>> adj_list;
 
 	public:
-		graph(int nv, int ne) { 
-			v = nv;
-			e = ne;
-			// Resize adj_list to contain v elements
-			adj_list.resize(v);
-		}
+		graph(int nv, int ne) : v(nv), e(ne), adj_list(nv) {}
 
 		~graph() {adj_list.clear();}
 
@@ -65,9 +61,11 @@ int main() {
 
 	return 0;
 }
-/** Pros: Takes space O(|V|+|E|). In the worst case, there can be C(V, 2)
- *	number of edges in a graph thus consuming O(V^2) space.
- *	
- *	Cons: Queries like whether there is an edge from vertex u to vertex v
- *	are not efficient and take O(V) time. Deleting an edge is also ineffi-
- *	-cient as it might requires traversing a long list in a large graph.
+/**
+ * Pros: Takes space O(|V|+|E|). In the worst case, there can be C(V, 2)
+ * number of edges in a graph thus consuming O(V^2) space.
+ *
+ * Cons: Queries like whether there is an edge from vertex u to vertex v
+ * are not efficient and take O(V) time. Deleting an edge is also ineffi-
+ * -cient as it might requires traversing a long list in a large graph.
+ */