Prim's algorithm for finding minimum spanning tree (#89)

sidml · web-flow · commit e95bdc88d8a6 · 2021-10-14T14:44:51.000+02:00
* add graph slicing algorithm

* add graph slicing test cases

* update readme

* improve test coverage

* add prim's algorithm

* prim test &amp; result struct

* cmake &amp; new error message
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -51,13 +51,14 @@ add_executable(test_exe test/main.cpp
 						test/GraphTest.cpp
 						test/DijkstraTest.cpp
 						test/BellmanFordTest.cpp
+						test/FWTest.cpp
+						test/PrimTest.cpp
 						test/BFSTest.cpp
 						test/DFSTest.cpp
 						test/CycleCheckTest.cpp
 						test/RWOutputTest.cpp
 						test/PartitionTest.cpp
 						test/DialTest.cpp
-						test/FWTest.cpp
 						test/GraphSlicingTest.cpp
 				)
 target_include_directories(test_exe PUBLIC
diff --git a/include/Graph/Graph.hpp b/include/Graph/Graph.hpp
@@ -188,6 +188,13 @@ namespace CXXGRAPH
  		*/
 		virtual const FWResult floydWarshall() const;
 		/**
+ 		* @brief Function runs the prim algorithm and returns the minimum spanning tree
+ 		* if the graph is undirected.
+		* Note: No Thread Safe
+ 		* @return a vector containing id of nodes in minimum spanning tree.
+ 		*/
+		virtual const PrimResult prim() const;
+		/**
  		* \brief
  		* Function performs the breadth first search algorithm over the graph
 		* Note: No Thread Safe
@@ -241,6 +248,15 @@ namespace CXXGRAPH
 
 		/**
      	* \brief
+     	* This function checks if a graph is undirected
+		* Note: No Thread Safe
+     	*
+     	* @return true if the graph is undirected, else false.
+     	*/
+		virtual bool isUndirectedGraph() const;
+		
+		/**
+     	* \brief
      	* This function performs Graph Slicing based on connectivity
 		* 
 		* Mathematical definition of the problem:
@@ -1099,9 +1115,6 @@ namespace CXXGRAPH
 		result.errorMessage = "";
 		std::map<std::pair<unsigned long, unsigned long>, double> pairwise_dist;
 		auto nodeSet = getNodeSet();
-		const AdjacencyMatrix<T> adj = getAdjMatrix();
-		// n denotes the number of vertices in graph
-		auto n = nodeSet.size();
 		// create a pairwise distance matrix with distance node distances
 		// set to inf. Distance of node to itself is set as 0.
 		for (auto elem1 : nodeSet)
@@ -1174,6 +1187,87 @@ namespace CXXGRAPH
 		return result;
 	}
 
+	template <typename T>
+	const PrimResult Graph<T>::prim() const
+	{
+		PrimResult result;
+		result.success = false;
+		result.errorMessage = "";
+		result.mstCost = INF_DOUBLE;
+		if (!isUndirectedGraph())
+		{
+			result.errorMessage = ERR_DIR_GRAPH;
+			return result;
+		}
+		auto nodeSet = getNodeSet();
+		auto n = nodeSet.size();
+		const AdjacencyMatrix<T> adj = getAdjMatrix();
+
+		// setting all the distances initially to INF_DOUBLE
+		std::map<const Node<T> *, double> dist;
+		for (auto elem : adj)
+		{
+			dist[elem.first] = INF_DOUBLE;
+		}
+
+		// creating a min heap using priority queue
+		// first element of pair contains the distance
+		// second element of pair contains the vertex
+		std::priority_queue<std::pair<double, const Node<T> *>, std::vector<std::pair<double, const Node<T> *>>,
+							std::greater<std::pair<double, const Node<T> *>>>
+			pq;
+
+		// pushing the source vertex 's' with 0 distance in min heap
+		auto source = nodeSet.front();
+		pq.push(std::make_pair(0.0, source));
+		// initialize cost and start node of mst
+		result.result.push_back(source->getId());
+		result.mstCost = 0;
+		while (!pq.empty())
+		{
+			// second element of pair denotes the node / vertex
+			const Node<T> *currentNode = pq.top().second;
+			auto nodeId = currentNode->getId();			
+			if (std::find(result.result.begin(), result.result.end(), nodeId) == result.result.end())
+			{
+				result.result.push_back(nodeId);
+				result.mstCost += pq.top().first;
+			}
+
+			pq.pop();
+			// for all the reachable vertex from the currently exploring vertex
+			// we will try to minimize the distance
+			if (adj.find(currentNode) != adj.end())
+			{
+				for (std::pair<const Node<T> *, const Edge<T> *> elem : adj.at(currentNode))
+				{
+					// minimizing distances
+					if (elem.second->isWeighted().has_value() && elem.second->isWeighted().value())
+					{
+						const UndirectedWeightedEdge<T> *udw_edge = dynamic_cast<const UndirectedWeightedEdge<T> *>(elem.second);
+						if ( 
+							(udw_edge->getWeight() < dist[elem.first]) &&
+							(std::find(result.result.begin(), result.result.end(), elem.first->getId()) == result.result.end())
+						)
+
+						{
+							dist[elem.first] = udw_edge->getWeight();
+							pq.push(std::make_pair(dist[elem.first], elem.first));
+						}
+					}
+					else
+					{
+						// No Weighted Edge
+						result.errorMessage = ERR_NO_WEIGHTED_EDGE;
+						return result;
+					}
+				}
+			}
+		}
+		result.success = true;
+		return result;
+	}
+
 	template <typename T>
 	const std::vector<Node<T>> Graph<T>::breadth_first_search(const Node<T> &start) const
 	{
@@ -1421,6 +1515,22 @@ namespace CXXGRAPH
 		return true;
 	}
 
+	template <typename T>
+	bool Graph<T>::isUndirectedGraph() const
+	{
+		auto edgeSet = this->getEdgeSet();
+		for (auto edge : edgeSet)
+		{
+			if ((edge->isDirected().has_value() && edge->isDirected().value()))
+			{
+				//Found Directed Edge
+				return false;
+			}
+		}
+		//No Directed Edge
+		return true;
+	}
+
 	template <typename T>
 	const DialResult Graph<T>::dial(const Node<T> &source, int maxWeight) const
 	{
diff --git a/include/Utility/ConstString.hpp b/include/Utility/ConstString.hpp
@@ -26,6 +26,7 @@ namespace CXXGRAPH
 {
     //STRING ERROR CONST EXPRESSION
 	constexpr char ERR_NO_DIR_OR_UNDIR_EDGE[] = "Edge are neither Directed neither Undirected";
+	constexpr char ERR_DIR_GRAPH[] = "Graph is directed";
 	constexpr char ERR_NO_WEIGHTED_EDGE[] = "Edge are not Weighted";
 	constexpr char ERR_TARGET_NODE_NOT_REACHABLE[] = "Target Node not Reachable";
 	constexpr char ERR_TARGET_NODE_NOT_IN_GRAPH[] = "Target Node not inside Graph";
diff --git a/include/Utility/Typedef.hpp b/include/Utility/Typedef.hpp
@@ -86,6 +86,16 @@ namespace CXXGRAPH
 	};
 	typedef FWResult_struct FWResult;
 	
+	/// Struct that contains the information about Prim Algorithm results
+	struct PrimResult_struct
+	{
+		bool success;			  // TRUE if the function does not return error, FALSE otherwise
+		std::string errorMessage; //message of error
+		std::vector<unsigned long> result;  // MST
+		double mstCost;  // MST
+	};
+	typedef PrimResult_struct PrimResult;
+
 	/// Struct that contains the information about Dijsktra's Algorithm results
 	struct DialResult_struct
 	{
diff --git a/test/PrimTest.cpp b/test/PrimTest.cpp
@@ -0,0 +1,180 @@
+#include "gtest/gtest.h"
+#include "CXXGraph.hpp"
+
+// minimum spanning tree can differ so instead of checking 
+// the exact order of elements, we can check some properties 
+// like the length & cost of mst which must remain the same
+
+// example taken from
+// https://www.geeksforgeeks.org/prims-mst-for-adjacency-list-representation-greedy-algo-6/TEST(FWTest, test_1)
+TEST(PrimTest, test_1)
+{
+    CXXGRAPH::Node<int> node0(0, 0);
+    CXXGRAPH::Node<int> node1(1, 1);
+    CXXGRAPH::Node<int> node2(2, 2);
+    CXXGRAPH::Node<int> node3(3, 3);
+    CXXGRAPH::Node<int> node4(4, 4);
+    CXXGRAPH::Node<int> node5(5, 5);
+    CXXGRAPH::Node<int> node6(6, 6);
+    CXXGRAPH::Node<int> node7(7, 7);
+    CXXGRAPH::Node<int> node8(8, 8);
+
+    CXXGRAPH::UndirectedWeightedEdge<int> edge1(1, node0, node1, 4);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge2(2, node0, node7, 8);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge3(3, node1, node7, 11);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge4(3, node1, node2, 8);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge5(4, node7, node8, 7);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge6(3, node7, node6, 1);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge7(3, node8, node2, 2);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge8(3, node8, node6, 6);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge9(3, node2, node5, 4);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge10(3, node2, node3, 7);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge11(3, node6, node5, 2);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge12(3, node3, node4, 9);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge13(3, node3, node5, 14);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge14(3, node5, node4, 10);
+
+    std::list<const CXXGRAPH::Edge<int> *> edgeSet;
+    edgeSet.push_back(&edge1);
+    edgeSet.push_back(&edge2);
+    edgeSet.push_back(&edge3);
+    edgeSet.push_back(&edge4);
+    edgeSet.push_back(&edge5);
+    edgeSet.push_back(&edge6);
+    edgeSet.push_back(&edge7);
+    edgeSet.push_back(&edge8);
+    edgeSet.push_back(&edge9);
+    edgeSet.push_back(&edge10);
+    edgeSet.push_back(&edge11);
+    edgeSet.push_back(&edge12);
+    edgeSet.push_back(&edge13);
+    edgeSet.push_back(&edge14);
+
+    CXXGRAPH::Graph<int> graph(edgeSet);
+    CXXGRAPH::PrimResult res = graph.prim();
+
+    ASSERT_TRUE(res.success);
+    ASSERT_EQ(res.result.size(), graph.getNodeSet().size());
+    ASSERT_EQ(res.mstCost, 37);
+    ASSERT_EQ(res.errorMessage, "");
+}
+
+
+// example taken from
+// https://www.gatevidyalay.com/prims-algorithm-prim-algorithm-example/
+TEST(PrimTest, test_2)
+{
+    CXXGRAPH::Node<int> node1(1, 1);
+    CXXGRAPH::Node<int> node2(2, 2);
+    CXXGRAPH::Node<int> node3(3, 3);
+    CXXGRAPH::Node<int> node4(4, 4);
+    CXXGRAPH::Node<int> node5(5, 5);
+    CXXGRAPH::Node<int> node6(6, 6);
+    CXXGRAPH::Node<int> node7(7, 7);
+
+    CXXGRAPH::UndirectedWeightedEdge<int> edge1(1, node1, node2, 28);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge2(2, node1, node6, 10);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge3(3, node2, node7, 14);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge4(4, node2, node3, 16);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge5(5, node6, node5, 25);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge6(6, node7, node5, 24);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge7(7, node7, node4, 18);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge8(8, node5, node4, 22);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge9(9, node4, node3, 12);
+
+    std::list<const CXXGRAPH::Edge<int> *> edgeSet;
+    edgeSet.push_back(&edge1);
+    edgeSet.push_back(&edge2);
+    edgeSet.push_back(&edge3);
+    edgeSet.push_back(&edge4);
+    edgeSet.push_back(&edge5);
+    edgeSet.push_back(&edge6);
+    edgeSet.push_back(&edge7);
+    edgeSet.push_back(&edge8);
+    edgeSet.push_back(&edge9);
+
+    CXXGRAPH::Graph<int> graph(edgeSet);
+    CXXGRAPH::PrimResult res = graph.prim();
+
+    // double values[4][4] = {{0, -1, -2, 0}, {4, 0, 2, 4}, {5, 1, 0, 2}, {3, -1, 1, 0}};
+    // unsigned long mst[] = {}
+    ASSERT_TRUE(res.success);
+    ASSERT_EQ(res.result.size(), graph.getNodeSet().size());
+    ASSERT_EQ(res.mstCost, 99);
+    ASSERT_EQ(res.errorMessage, "");
+
+}
+
+
+// example taken from
+// https://www.gatevidyalay.com/prims-algorithm-prim-algorithm-example/
+TEST(PrimTest, test_3)
+{
+    CXXGRAPH::Node<int> node1(1, 1);
+    CXXGRAPH::Node<int> node2(2, 2);
+    CXXGRAPH::Node<int> node3(3, 3);
+    CXXGRAPH::Node<int> node4(4, 4);
+    CXXGRAPH::Node<int> node5(5, 5);
+    CXXGRAPH::Node<int> node6(6, 6);
+    CXXGRAPH::Node<int> node7(7, 7);
+
+    CXXGRAPH::UndirectedWeightedEdge<int> edge1(1, node1, node2, 1);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge2(2, node1, node3, 5);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge3(3, node2, node5, 7);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge4(4, node2, node4, 8);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge5(5, node2, node3, 4);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge6(6, node3, node4, 6);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge7(7, node3, node6, 2);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge8(8, node4, node6, 9);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge9(9, node4, node5, 11);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge10(9, node5, node7, 10);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge11(9, node5, node6, 3);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge12(9, node6, node7, 12);
+
+    std::list<const CXXGRAPH::Edge<int> *> edgeSet;
+    edgeSet.push_back(&edge1);
+    edgeSet.push_back(&edge2);
+    edgeSet.push_back(&edge3);
+    edgeSet.push_back(&edge4);
+    edgeSet.push_back(&edge5);
+    edgeSet.push_back(&edge6);
+    edgeSet.push_back(&edge7);
+    edgeSet.push_back(&edge8);
+    edgeSet.push_back(&edge9);
+    edgeSet.push_back(&edge10);
+    edgeSet.push_back(&edge11);
+    edgeSet.push_back(&edge12);
+
+    CXXGRAPH::Graph<int> graph(edgeSet);
+    CXXGRAPH::PrimResult res = graph.prim();
+
+    ASSERT_TRUE(res.success);
+    ASSERT_EQ(res.result.size(), graph.getNodeSet().size());
+    ASSERT_EQ(res.mstCost, 26);
+    ASSERT_EQ(res.errorMessage, "");
+}
+
+// test for directed and no weighted edge errors
+TEST(PrimTest, test_4)
+{
+    CXXGRAPH::Node<int> node1(1, 1);
+    CXXGRAPH::Node<int> node2(2, 2);
+    CXXGRAPH::Node<int> node3(3, 3);
+    CXXGRAPH::DirectedWeightedEdge<int> edge1(1, node1, node2, 1);
+    CXXGRAPH::DirectedWeightedEdge<int> edge2(2, node2, node3, 1);
+    std::list<const CXXGRAPH::Edge<int> *> edgeSet;
+    edgeSet.push_back(&edge1);
+    edgeSet.push_back(&edge2);
+    CXXGRAPH::Graph<int> graph(edgeSet);
+    CXXGRAPH::PrimResult res = graph.prim();
+    ASSERT_FALSE(res.success);
+    ASSERT_EQ(res.errorMessage, CXXGRAPH::ERR_DIR_GRAPH);
+
+    CXXGRAPH::UndirectedEdge<int> edge3(3, node1, node2);
+    std::list<const CXXGRAPH::Edge<int> *> edgeSet1;
+    edgeSet1.push_back(&edge3);
+    CXXGRAPH::Graph<int> graph1(edgeSet1);
+    res = graph1.prim();
+    ASSERT_FALSE(res.success);
+    ASSERT_EQ(res.errorMessage, CXXGRAPH::ERR_NO_WEIGHTED_EDGE);
+}

Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@ namespace CXXGRAPH`
`26`	`26`	`{`
`27`	`27`	`//STRING ERROR CONST EXPRESSION`
`28`	`28`	`constexpr char ERR_NO_DIR_OR_UNDIR_EDGE[] = "Edge are neither Directed neither Undirected";`
	`29`	`+ constexpr char ERR_DIR_GRAPH[] = "Graph is directed";`
`29`	`30`	`constexpr char ERR_NO_WEIGHTED_EDGE[] = "Edge are not Weighted";`
`30`	`31`	`constexpr char ERR_TARGET_NODE_NOT_REACHABLE[] = "Target Node not Reachable";`
`31`	`32`	`constexpr char ERR_TARGET_NODE_NOT_IN_GRAPH[] = "Target Node not inside Graph";`