feature: ham cycle logic added

Author: Debashis08

Headers/0003_Graph/0005_HamiltonianPathAndCycle.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include<map>
-#include<list>
+#include<unordered_set>
 #include<vector>
 using namespace std;
 
@@ -18,11 +18,16 @@ class HamiltonianGraph
 private:
 	bool isHamiltonianCyclePresent;
 	bool isHamiltonianPathPresent;
-	map<HamiltonianNode*, list<HamiltonianNode*>> _adjlist;
+	int visitedNodeCount;
+	map<HamiltonianNode*, unordered_set<HamiltonianNode*>> _adjlist;
 	map<int, HamiltonianNode*> _nodeMap;
+	vector<HamiltonianNode*> _hamiltonianPath;
 	HamiltonianNode* MakeOrFindNode(int value);
+	bool IsSafe(HamiltonianNode* nodeU, HamiltonianNode* nodeV);
+	bool HamiltonianCycleAndPathUtil(HamiltonianNode* node);
 
 public:
 	void PushUndirectedEdge(int valueU, int valueV);
 	void PushSingleNode(int valueU);
+	void FindHamiltonianCycleAndPath();
 };

SourceCodes/0003_Graph/0005_HamiltonianPathAndCycle.cc

@@ -0,0 +1,93 @@
+#include "../Headers/0003_Graph/0005_HamiltonianPathAndCycle.h"
+
+using namespace std;
+
+HamiltonianNode::HamiltonianNode(int value)
+{
+	this->data = value;
+	this->isVisited = false;
+}
+
+// HamiltonianGraph Private Member Methods
+HamiltonianNode* HamiltonianGraph::MakeOrFindNode(int value)
+{
+	HamiltonianNode* node = nullptr;
+	if (this->_nodeMap.find(value) == this->_nodeMap.end())
+	{
+		node = new HamiltonianNode(value);
+		this->_nodeMap[value] = node;
+	}
+	else
+	{
+		node = this->_nodeMap[value];
+	}
+	return node;
+}
+
+bool HamiltonianGraph::IsSafe(HamiltonianNode* nodeU, HamiltonianNode* nodeV)
+{
+	if (this->_adjlist[nodeU].find(nodeV) == this->_adjlist[nodeU].end())
+	{
+		return false;
+	}
+	if (nodeV->isVisited == true)
+	{
+		return false;
+	}
+	return true;
+}
+
+bool HamiltonianGraph::HamiltonianCycleAndPathUtil(HamiltonianNode* nodeU)
+{
+	if (this->visitedNodeCount == this->_nodeMap.size()-1)
+	{
+		if (this->_adjlist[nodeU].find(this->_hamiltonianPath[0]) != this->_adjlist[nodeU].end())
+		{
+			this->isHamiltonianCyclePresent = true;
+			return true;
+		}
+		this->isHamiltonianPathPresent = true;
+		return false;
+	}
+	for (auto& iterator : this->_nodeMap)
+	{
+		if (this->IsSafe(nodeU, iterator.second))
+		{
+			this->_hamiltonianPath.push_back(iterator.second);
+			iterator.second->isVisited = true;
+			this->visitedNodeCount++;
+			if (this->HamiltonianCycleAndPathUtil(iterator.second))
+			{
+				return true;
+			}
+			this->_hamiltonianPath.pop_back();
+			iterator.second->isVisited = false;
+			this->visitedNodeCount--;
+		}
+	}
+	return false;
+}
+
+// HamiltonianGraph Public Member Methods
+void HamiltonianGraph::PushUndirectedEdge(int valueU, int valueV)
+{
+	HamiltonianNode* nodeU = this->MakeOrFindNode(valueU);
+	HamiltonianNode* nodeV = this->MakeOrFindNode(valueV);
+
+	this->_adjlist[nodeU].insert(nodeV);
+	this->_adjlist[nodeV].insert(nodeU);
+}
+
+void HamiltonianGraph::PushSingleNode(int valueU)
+{
+	HamiltonianNode* nodeU = this->MakeOrFindNode(valueU);
+}
+
+void HamiltonianGraph::FindHamiltonianCycleAndPath()
+{
+	HamiltonianNode* node = this->_nodeMap[0];
+	this->_hamiltonianPath.push_back(node);
+	node->isVisited = true;
+	this->visitedNodeCount = 1;
+	this->HamiltonianCycleAndPathUtil(node);
+}