Merge branch 'master' into fixgraph

graph/is_graph_bipartite.cpp

@@ -0,0 +1,163 @@
+/**
+ *  @file
+ *
+ *	@brief Algorithm to check whether a graph is [bipartite](https://en.wikipedia.org/wiki/Bipartite_graph)
+ *	
+ *	@details
+ *	A graph is a collection of nodes also called vertices and these vertices
+ *	are connected by edges.A bipartite graph is a graph whose vertices can be
+ * 	divided into two disjoint and independent sets U and V such that every edge 
+ *	connects a vertex in U to one in V. 	
+ *	
+ *	The given Algorithm will determine whether the given graph is bipartite or not
+ *	
+ *	<pre>
+ * 	Example - Here is a graph g1 with 5 vertices and is bipartite
+ *	
+ *		1   4
+ *	   / \ / \
+ *	  2   3   5
+ *	
+ *	Example - Here is a graph G2 with 3 vertices and is not bipartite
+ *	
+ *		1 --- 2
+ *		 \   /
+ *		   3
+ *	
+ *	</pre>
+ *
+ *	@author [Akshat Vaya](https://github.com/AkVaya)
+ *		
+ */
+#include <iostream>
+#include <vector>
+#include <queue>
+
+/**
+ * @namespace graph
+ * @brief Graph algorithms
+ */
+namespace graph{
+	/**
+	 * @namespace is_graph_bipartite
+	 * @brief Functions for checking whether a graph is bipartite or not
+	 */
+	namespace is_graph_bipartite{
+		/**
+		 * @brief Class for representing graph as an adjacency list.
+		 */
+		class Graph {
+ 			private: 
+ 				int n;						/// size of the graph
+
+	    		std::vector<std::vector <int> > adj;	/// adj stores the graph as an adjacency list
+
+		    	std::vector<int> side;			///stores the side of the vertex
+
+				static const int nax = 5e5 + 1;
+
+
+	 		public:
+	    		/**
+    			 * @brief Constructor that initializes the graph on creation
+    			 */
+	    		explicit Graph(int size = nax){
+    				n = size;
+    				adj.resize(n);
+	    			side.resize(n,-1);
+    			}
+
+		    	void addEdge(int u, int v);     /// function to add edges to our graph
+
+				bool is_bipartite();    	/// function to check whether the graph is bipartite or not
+
+		};
+		/**
+ 		 * @brief Function that add an edge between two nodes or vertices of graph
+		 *
+		 * @param u is a node or vertex of graph
+		 * @param v is a node or vertex of graph
+		 */
+		void Graph::addEdge(int u, int v) {
+		    adj[u-1].push_back(v-1);
+    		adj[v-1].push_back(u-1);
+		}
+		/**
+		 *	@brief function that checks whether the graph is bipartite or not
+		 *	the function returns true if the graph is a bipartite graph
+		 *	the function returns false if the graph is not a bipartite graph
+		 *
+		 *	@details
+		 *	Here, side refers to the two disjoint subsets of the bipartite graph.
+		 *	Initially, the values of side are set to -1 which is an unassigned state. A for loop is run for every vertex of the graph.
+		 *	If the current edge has no side assigned to it, then a Breadth First Search operation is performed.
+		 *	If two neighbours have the same side then the graph will not be bipartite and the value of check becomes false.
+		 *	If and only if each pair of neighbours have different sides, the value of check will be true and hence the graph bipartite.
+		 * 
+		 */
+		bool Graph::is_bipartite(){
+			bool check = true;
+			std::queue<int> q;
+			for (int current_edge = 0; current_edge < n; ++current_edge)
+			{
+				if(side[current_edge] == -1){
+					q.push(current_edge);
+					side[current_edge] = 0;
+					while(q.size()){
+						int current = q.front();
+						q.pop();
+						for(auto neighbour : adj[current]){
+							if(side[neighbour] == -1){
+								side[neighbour] = (1 ^ side[current]);
+								q.push(neighbour);
+							}
+							else{
+								check &= (side[neighbour] != side[current]);
+							}
+						}
+					}
+				}
+			}
+			return check;
+		}
+	} /// namespace is_graph_bipartite
+} /// namespace graph
+/**
+ * 	Function to test the above algorithm
+ *	@returns none
+ */
+static void test(){
+	graph::is_graph_bipartite::Graph G1(5);	/// creating graph G1 with 5 vertices
+	/// adding edges to the graphs as per the illustrated example
+	G1.addEdge(1,2);
+	G1.addEdge(1,3);
+	G1.addEdge(3,4);
+	G1.addEdge(4,5);
+
+	graph::is_graph_bipartite::Graph G2(3);	/// creating graph G2 with 3 vertices
+	/// adding edges to the graphs as per the illustrated example
+	G2.addEdge(1,2);
+	G2.addEdge(1,3);
+	G2.addEdge(2,3);
+
+	/// checking whether the graphs are bipartite or not
+	if(G1.is_bipartite()){
+		std::cout<<"The given graph G1 is a bipartite graph\n";
+	} 
+	else{
+		std::cout<<"The given graph G1 is not a bipartite graph\n";
+	}
+	if(G2.is_bipartite()){
+		std::cout<<"The given graph G2 is a bipartite graph\n";
+	} 
+	else{
+		std::cout<<"The given graph G2 is not a bipartite graph\n";
+	}
+}
+/**
+ * Main function
+ */
+int main(){
+	test();  ///Testing
+	return 0;
+}

math/fibonacci.cpp

@@ -14,7 +14,7 @@
 /**
  * Recursively compute sequences
  */
-int fibonacci(unsigned int n) {
+unsigned int fibonacci(unsigned int n) {
     /* If the input is 0 or 1 just return the same
        This will set the first 2 values of the sequence */
     if (n <= 1)
@@ -24,8 +24,40 @@ int fibonacci(unsigned int n) {
     return fibonacci(n - 1) + fibonacci(n - 2);
 }
 
+/**
+ * Function for testing the fibonacci() function with a few
+ * test cases and assert statement.
+ * @returns `void`
+*/
+static void test() {
+    unsigned int test_case_1 = fibonacci(0);
+    assert(test_case_1 == 0);
+    std::cout << "Passed Test 1!" << std::endl;
+
+    unsigned int test_case_2 = fibonacci(1);
+    assert(test_case_2 == 1);
+    std::cout << "Passed Test 2!" << std::endl;
+
+    unsigned int test_case_3 = fibonacci(2);
+    assert(test_case_3 == 1);
+    std::cout << "Passed Test 3!" << std::endl;
+
+    unsigned int test_case_4 = fibonacci(3);
+    assert(test_case_4 == 2);
+    std::cout << "Passed Test 4!" << std::endl;
+
+    unsigned int test_case_5 = fibonacci(4);
+    assert(test_case_5 == 3);
+    std::cout << "Passed Test 5!" << std::endl;
+
+    unsigned int test_case_6 = fibonacci(15);
+    assert(test_case_6 == 610);
+    std::cout << "Passed Test 6!" << std::endl << std::endl;
+}
+
 /// Main function
 int main() {
+    test();
     int n;
     std::cin >> n;
     assert(n >= 0);