Add implementations of:

* Graph representations
* Traversal algorithms
* Algos for detecting cycle
* Topological Sorting algo
* An MST algo (Prim's)

Author: ivmarkp

Detect_Cycle/directed.cc

@@ -0,0 +1,86 @@
+/** 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.
+ *
+ *	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;
+
+class graph {
+    int nv;
+    vector<list<int>> adj;
+    // A utility function to be used by main "cyclic" function
+    bool util(int s, vector<bool>& visited, vector<bool>& recur_stack);
+
+    public:
+        graph(int num) : nv(num), adj(num) {}
+    	void addEdge(int u, int v) {
+    		adj[u].push_back(v);
+    	}
+    	bool cyclic();
+};
+
+bool graph::util(int s, vector<bool>& visited, vector<bool>& recur_stack) {
+	if (visited[s] == false) {
+		
+		// Mark the current vertex visited and a part of recur_stack.
+		visited[s] = true;
+		recur_stack[s] = true;
+		
+		// Recur through all the adjacent vertices to the current vertex
+		for (auto i = adj[s].begin(); i != adj[s].end(); ++i) {
+			// If an adjacent has not been visited then recur for it.
+			if (!visited[*i]) {
+				if (util(*i, visited, recur_stack))
+					return true;
+			}
+			// If an adjacent has been visited and is present in the
+			// recur_stack then it forms a cycle in the graph.
+			else if (recur_stack[*i])
+				return true;
+		}
+	}
+	// Set the current vertex as false in recur_stack
+	// to mark it as removed from it.
+	recur_stack[s] = false;
+	
+	return false;
+}
+
+bool graph::cyclic() {
+	// Mark all vertices as not visited.
+    vector<bool> visited(nv, false);
+    vector<bool> recur_stack(nv, false);
+	
+	// Call Util for each vertex.
+    for (int i = 0; i < nv; i++) {
+    	// Returns true if a cycle is present in the graph.
+        if (util(i, visited, recur_stack))
+            return true;
+    }
+    return false;
+}
+
+int main() {
+	graph g(4);
+	
+	g.addEdge(0, 1);
+	g.addEdge(0, 2);
+	g.addEdge(1, 3);
+	g.addEdge(2, 3);
+	g.addEdge(3, 1);
+
+	if (g.cyclic())
+		cout << "Graph is cyclic.\n";
+	else
+		cout << "Not a cyclic graph.\n";
+	
+	return 0;
+}
+// Time Complexity: Same as DFS i.e. O(V + E).

Detect_Cycle/directed_color.cc

@@ -0,0 +1,75 @@
+/** 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.
+ */
+#include <bits/stdc++.h>
+using namespace std;
+
+enum COLOR {WHITE, GRAY, BLACK};
+
+class graph {
+    int nv;
+    vector<list<int>> adj;
+    // A utility function to be used by main "cyclic" function
+    bool util(int s, vector<int>& color);
+    public:
+        graph(int num) : nv(num), adj(num) {}
+    	void addEdge(int u, int v) {
+    		adj[u].push_back(v);
+    	}
+    	bool cyclic();
+};
+
+bool graph::util(int s, vector<int>& visited) {
+	if (visited[s] == false) {
+		
+		visited[s] = GRAY;
+
+		// Recur through all the adjacent vertices to the current vertex
+		for (auto i = adj[s].begin(); i != adj[s].end(); ++i) {
+			// If the current vertex has not been processed and there is
+			// a back edge in subtree rooted at it.
+			if (visited[*i] == WHITE && util(*i, visited))
+				return true;
+			if (visited[*i] == GRAY)
+				return true;
+		}
+	}
+	// Mark the vertex as fully processed.
+	visited[s] = BLACK;
+	
+	return false;
+}
+
+bool graph::cyclic() {
+	// Mark all vertices as not visited.
+    vector<int> color(nv, WHITE);
+	
+	// Call Util for each vertex.
+    for (int i = 0; i < nv; i++) {
+    	// Returns true if a cycle is present in the graph.
+        if (util(i, color))
+            return true;
+    }
+    
+    return false;
+}
+
+int main() {
+	graph g(4);
+	
+	g.addEdge(0, 1);
+	g.addEdge(0, 2);
+	g.addEdge(1, 3);
+	g.addEdge(2, 3);
+	g.addEdge(3, 1);
+
+	if (g.cyclic())
+		cout << "Graph is cyclic.\n";
+	else
+		cout << "Not a cyclic graph.\n";
+	
+	return 0;
+}
+// Time Complexity: Same as DFS i.e. O(V + E).

Detect_Cycle/undirected.cc

@@ -0,0 +1,77 @@
+/** 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.
+ */
+#include <bits/stdc++.h>
+using namespace std;
+
+class graph {
+    int nv;
+    vector<list<int>> adj;
+    // A utility function to be used by main "cyclic" function
+    bool util(int s, vector<bool>& visited, int parent);
+    public:
+        graph(int num) : nv(num), adj(num) {}
+    	void addEdge(int u, int v) {
+    		// Birectional edges
+    		adj[u].push_back(v);
+    		adj[v].push_back(u);
+    	}
+    	bool cyclic();
+};
+
+bool graph::util(int s, vector<bool>& visited, int parent) {
+	visited[s] = true;
+	
+	// Recur through all the adjacent vertices to the current vertex
+	for (auto i = adj[s].begin(); i != adj[s].end(); ++i) {
+		// If an adjacent vertex has not been visited then recur for it.
+		if (!visited[*i]) {
+			if(util(*i, visited, s))
+				return true;
+		}
+		
+		// If an adjacent has been visited and it's not the parent
+		// then it forms a cycle in the graph.
+		else if (*i != parent)
+			return true;
+	}
+	return false;
+}
+
+bool graph::cyclic() {
+	// Mark all vertices as not visited.
+    vector<bool> visited(nv, false);
+	
+	// Call Util for each vertex.
+    for (int i = 0; i < nv; i++) {
+    	// Recur only if i has not been visited.
+    	if (!visited[i]) {
+        	if (util(i, visited, -1))
+            	return true;
+        }
+    }
+    return false;
+}
+
+int main() {
+	graph g(4);
+	
+	g.addEdge(0, 1);
+	g.addEdge(0, 2);
+	g.addEdge(1, 3);
+	g.addEdge(2, 3);
+
+	if (g.cyclic())
+		cout << "Graph is cyclic.\n";
+	else
+		cout << "Not a cyclic graph.\n";
+	
+	return 0;
+}
+// Time Complexity: Same as DFS i.e. O(V + E).

Min_Spanning_Tree/prim_list.cc

@@ -0,0 +1,85 @@
+/** Given an undirected, connected and weighted graph, find MST of the graphs
+ *	using Prim’s algorithm.
+ */
+#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;
+
+    public:
+        graph(int num) : nv(num), adj(num) {}
+    	void addEdge(int u, int v, int wt) {
+    		adj[u].push_back(make_pair(v, wt));
+    		adj[v].push_back(make_pair(u, wt));
+    	}
+    	void prims(int s);
+    	void print_mst();
+};
+
+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);
+
+	// 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
+			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));
+				parent[v] = u;
+			}
+		}
+	}
+	for (int i = 1; i < nv; i++)
+		cout << parent[i] << " -> " << i << endl;
+	cout << endl;
+}
+
+
+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;
+}