Introduced Cycle Check with BFS for directed Graph

Author: ZigRazor

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.9)
 
 # set the project name and version
-project(CXXGraph VERSION 0.0.5)
+project(CXXGraph VERSION 0.0.6)
 
 configure_file(CXXGraphConfig.h.in ${PROJECT_SOURCE_DIR}/include/CXXGraphConfig.h)
 

README.md

@@ -43,7 +43,7 @@ Applications of Breadth First Search are :
 
   And there are many more...
 
-  ####Cycle Detection
+   #### Cycle Detection
    [Cycle (graph theory)](https://en.wikipedia.org/wiki/Cycle_(graph_theory))
    The existence of a cycle in directed and undirected graphs can be determined by whether depth-first search (DFS) finds an edge that points to an ancestor of the current vertex (it contains a back edge). All the back edges which DFS skips over are part of cycles. In an undirected graph, the edge to the parent of a node should not be counted as a back edge, but finding any other already visited vertex will indicate a back edge. In the case of undirected graphs, only O(n) time is required to find a cycle in an n-vertex graph, since at most n − 1 edges can be tree edges.
 

include/Graph.hpp

@@ -517,6 +517,16 @@ namespace CXXGRAPH
      	* @return true if a cycle is detected, else false. ( false is returned also if the graph in indirected)
      	*/
 		const bool isCyclicDirectedGraphDFS() const;
+
+		/** 
+		* \brief
+     	* This function uses BFS to check for cycle in the graph.
+     	* Pay Attention, this function work only with directed Graph
+     	* 
+     	* @return true if a cycle is detected, else false. ( false is returned also if the graph in indirected)
+     	*/
+		const bool isCyclicDirectedGraphBFS() const;
+
 		/**
      	* \brief
      	* This function checks if a graph is directed
@@ -807,7 +817,8 @@ namespace CXXGRAPH
 	template <typename T>
 	const bool Graph<T>::isCyclicDirectedGraphDFS() const
 	{
-		if(!isDirectedGraph()){
+		if (!isDirectedGraph())
+		{
 			return false;
 		}
 		enum nodeStates : uint8_t
@@ -826,8 +837,9 @@ namespace CXXGRAPH
          *
          * Initially, all nodes are in "not_visited" state.
          */
-		std::map<unsigned long,nodeStates> state;
-		for (auto node : nodeSet){
+		std::map<unsigned long, nodeStates> state;
+		for (auto node : nodeSet)
+		{
 			state[node->getId()] = not_visited;
 		}
 		int stateCounter = 0;
@@ -841,8 +853,8 @@ namespace CXXGRAPH
 			if (state[node->getId()] == not_visited)
 			{
 				// Check for cycle.
-				std::function<bool(AdjacencyMatrix<T>&,std::map<unsigned long,nodeStates>&,const Node<T>*)> isCyclicDFSHelper;
-				isCyclicDFSHelper = [this, &isCyclicDFSHelper](AdjacencyMatrix<T>& adjMatrix, std::map<unsigned long,nodeStates>& states, const Node<T>* node)
+				std::function<bool(AdjacencyMatrix<T> &, std::map<unsigned long, nodeStates> &, const Node<T> *)> isCyclicDFSHelper;
+				isCyclicDFSHelper = [this, &isCyclicDFSHelper](AdjacencyMatrix<T> &adjMatrix, std::map<unsigned long, nodeStates> &states, const Node<T> *node)
 				{
 					// Add node "in_stack" state.
 					states[node->getId()] = in_stack;
@@ -891,13 +903,84 @@ namespace CXXGRAPH
 		// the graph. Return false.
 		return false;
 	}
-	
-	template<typename T>
+
+	template <typename T>
+	const bool Graph<T>::isCyclicDirectedGraphBFS() const
+	{
+		if (!isDirectedGraph())
+		{
+			return false;
+		}
+		auto adjMatrix = this->getAdjMatrix();
+		auto nodeSet = this->getNodeSet();
+
+		std::map<unsigned long, unsigned int> indegree;
+		for (auto node : nodeSet)
+		{
+			indegree[node->getId()] = 0;
+		}
+		// Calculate the indegree i.e. the number of incident edges to the node.
+		for (auto const &list : adjMatrix)
+		{
+			auto children = list.second;
+			for (auto const &child : children)
+			{
+				indegree[std::get<0>(child)->getId()]++;
+			}
+		}
+
+		std::queue<const Node<T> *> can_be_solved;
+		for (auto node : nodeSet)
+		{
+			// If a node doesn't have any input edges, then that node will
+			// definately not result in a cycle and can be visited safely.
+			if (!indegree[node->getId()])
+			{
+				can_be_solved.emplace(&(*node));
+			}
+		}
+
+		// Vertices that need to be traversed.
+		auto remain = this->getNodeSet().size();
+		// While there are safe nodes that we can visit.
+		while (!can_be_solved.empty())
+		{
+			auto solved = can_be_solved.front();
+			// Visit the node.
+			can_be_solved.pop();
+			// Decrease number of nodes that need to be traversed.
+			remain--;
+
+			// Visit all the children of the visited node.
+			auto it = adjMatrix.find(solved);
+			if (it != adjMatrix.end())
+			{
+				for (auto child : it->second)
+				{
+					// Check if we can visited the node safely.
+					if (--indegree[std::get<0>(child)->getId()] == 0)
+					{
+						// if node can be visited safely, then add that node to
+						// the visit queue.
+						can_be_solved.emplace(std::get<0>(child));
+					}
+				}
+			}
+		}
+
+		// If there are still nodes that we can't visit, then it means that
+		// there is a cycle and return true, else return false.
+		return !(remain == 0);
+	}
+
+	template <typename T>
 	const bool Graph<T>::isDirectedGraph() const
 	{
 		auto edgeSet = this->getEdgeSet();
-		for( auto edge : edgeSet){
-			if( !(edge->isDirected().has_value() && edge->isDirected().value())){
+		for (auto edge : edgeSet)
+		{
+			if (!(edge->isDirected().has_value() && edge->isDirected().value()))
+			{
 				//Found Undirected Edge
 				return false;
 			}

test/CycleCheckTest.cpp

@@ -71,3 +71,73 @@ TEST(CycleCheckTest, test_4)
     ASSERT_EQ(res,true);
 }
 
+TEST(CycleCheckTest, test_5)
+{
+    CXXGRAPH::Node<int> node1(1, 1);
+    CXXGRAPH::Node<int> node2(2, 2);
+    CXXGRAPH::Node<int> node3(3, 3);
+    std::pair<const CXXGRAPH::Node<int> *, const CXXGRAPH::Node<int> *> pairNode(&node1, &node2);
+    CXXGRAPH::DirectedWeightedEdge<int> edge1(1, pairNode,1);
+    CXXGRAPH::DirectedWeightedEdge<int> edge2(2, node2, node3,1);
+    CXXGRAPH::DirectedWeightedEdge<int> edge3(3, node1, node3,6);
+    std::set<const CXXGRAPH::Edge<int> *> edgeSet;
+    edgeSet.insert(&edge1);
+    edgeSet.insert(&edge2);
+    edgeSet.insert(&edge3);
+    CXXGRAPH::Graph<int> graph(edgeSet);
+    bool res= graph.isCyclicDirectedGraphBFS();
+    ASSERT_EQ(res,false);
+}
+
+TEST(CycleCheckTest, test_6)
+{
+    CXXGRAPH::Node<int> node1(1, 1);
+    CXXGRAPH::Node<int> node2(2, 2);
+    CXXGRAPH::Node<int> node3(3, 3);
+    std::pair<const CXXGRAPH::Node<int> *, const CXXGRAPH::Node<int> *> pairNode(&node1, &node2);
+    CXXGRAPH::DirectedWeightedEdge<int> edge1(1, pairNode,1);
+    CXXGRAPH::DirectedWeightedEdge<int> edge2(2, node2, node3,1);
+    std::set<const CXXGRAPH::Edge<int> *> edgeSet;
+    edgeSet.insert(&edge1);
+    edgeSet.insert(&edge2);
+    CXXGRAPH::Graph<int> graph(edgeSet);
+    bool res= graph.isCyclicDirectedGraphBFS();
+    ASSERT_EQ(res,false);
+}
+
+TEST(CycleCheckTest, test_7)
+{
+    CXXGRAPH::Node<int> node1(1, 1);
+    CXXGRAPH::Node<int> node2(2, 2);
+    CXXGRAPH::Node<int> node3(3, 3);
+    std::pair<const CXXGRAPH::Node<int> *, const CXXGRAPH::Node<int> *> pairNode(&node1, &node2);
+    CXXGRAPH::DirectedWeightedEdge<int> edge1(1, pairNode,1);
+    CXXGRAPH::DirectedWeightedEdge<int> edge2(2, node2, node3,1);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge3(3, node1, node3,6);
+    std::set<const CXXGRAPH::Edge<int> *> edgeSet;
+    edgeSet.insert(&edge1);
+    edgeSet.insert(&edge2);
+    edgeSet.insert(&edge3);
+    CXXGRAPH::Graph<int> graph(edgeSet);    
+    bool res= graph.isCyclicDirectedGraphBFS();
+    ASSERT_EQ(res,false);
+}
+
+TEST(CycleCheckTest, test_8)
+{
+    CXXGRAPH::Node<int> node1(1, 1);
+    CXXGRAPH::Node<int> node2(2, 2);
+    CXXGRAPH::Node<int> node3(3, 3);
+    std::pair<const CXXGRAPH::Node<int> *, const CXXGRAPH::Node<int> *> pairNode(&node1, &node2);
+    CXXGRAPH::DirectedWeightedEdge<int> edge1(1, pairNode,1);
+    CXXGRAPH::DirectedWeightedEdge<int> edge2(2, node2, node3,1);
+    CXXGRAPH::DirectedWeightedEdge<int> edge3(3, node3, node1,6);
+    std::set<const CXXGRAPH::Edge<int> *> edgeSet;
+    edgeSet.insert(&edge1);
+    edgeSet.insert(&edge2);
+    edgeSet.insert(&edge3);
+    CXXGRAPH::Graph<int> graph(edgeSet);
+    bool res= graph.isCyclicDirectedGraphBFS();
+    ASSERT_EQ(res,true);
+}
+