feature: DAG shortest path initial changes

Author: Debashis08

Headers/0003_Graph/0010_DirectedAcyclicGraphShortestPath.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include<map>
+#include<vector>
+#include<list>
+using namespace std;
+
+namespace DirectedAcyclicGraphShortestPath
+{
+	enum color {WHITE, GRAY, BLACK};
+
+	class Node
+	{
+	public:
+		int data;
+		int color;
+		int distance;
+		Node* parent;
+		Node(int data);
+	};
+
+	class Edge
+	{
+	public:
+		Node* nodeU;
+		Node* nodeV;
+		int weight;
+		Edge(Node* nodeU, Node* nodeV, int weight);
+	};
+
+	class Graph
+	{
+	private:
+		map<Node*, vector<Node*>> _adjlist;
+		map<int, Node*> _nodeMap;
+		map<Node*, vector<Edge*>> _edgeMap;
+		list<Node*> _topologicalSortedNodeList;
+		Node* MakeOrFindNode(int data);
+		void DepthFirstSearch(Node* node);
+		void TopologicalSort();
+		void InitializeSingleSource(Node* sourceNode);
+		void Relax(Edge* edge);
+		void GetShortestPath(Node* node, vector<int>& path);
+
+
+	public:
+		void PushDirectedEdge(int valueU, int valueV, int weight);
+		void FindDAGShortestPath(int data);
+		vector<int> GetDAGShortestPath(int data);
+	};
+}

SourceCodes/0003_Graph/0010_DirectedAcyclicGraphShortestPath.cc

@@ -0,0 +1,124 @@
+#include "../Headers/0003_Graph/0010_DirectedAcyclicGraphShortestPath.h"
+#include<climits>
+using namespace std;
+
+namespace DirectedAcyclicGraphShortestPath
+{
+	Node::Node(int data)
+	{
+		this->data = data;
+		this->color = WHITE;
+		this->distance = INT_MAX;
+		this->parent = nullptr;
+	}
+
+	Edge::Edge(Node* nodeU, Node* nodeV, int weight)
+	{
+		this->nodeU = nodeU;
+		this->nodeV = nodeV;
+		this->weight = weight;
+	}
+
+	// Graph Private Member Methods
+	Node* Graph::MakeOrFindNode(int data)
+	{
+		Node* node = nullptr;
+		if (this->_nodeMap.find(data) == this->_nodeMap.end())
+		{
+			node = new Node(data);
+			this->_nodeMap[data] = node;
+		}
+		else
+		{
+			node = this->_nodeMap[data];
+		}
+		return node;
+	}
+
+	void Graph::DepthFirstSearch(Node* nodeU)
+	{
+		nodeU->color = GRAY;
+		for (auto nodeV : this->_adjlist[nodeU])
+		{
+			if (nodeV->color == WHITE)
+			{
+				nodeV->parent = nodeU;
+				this->DepthFirstSearch(nodeV);
+			}
+		}
+		nodeU->color = BLACK;
+		this->_topologicalSortedNodeList.push_front(nodeU);
+	}
+
+	void Graph::TopologicalSort()
+	{
+		for (auto& iterator : this->_nodeMap)
+		{
+			if (iterator.second->color == WHITE)
+			{
+				this->DepthFirstSearch(iterator.second);
+			}
+		}
+	}
+
+	void Graph::InitializeSingleSource(Node* sourceNode)
+	{
+		for (auto& iterator : this->_nodeMap)
+		{
+			iterator.second->distance = INT_MAX;
+			iterator.second->parent = nullptr;
+		}
+		sourceNode->distance = 0;
+	}
+
+	void Graph::Relax(Edge* edge)
+	{
+		if (edge->nodeV->distance > (edge->nodeU->distance + edge->weight))
+		{
+			edge->nodeV->distance = edge->nodeU->distance + edge->weight;
+			edge->nodeV->parent = edge->nodeU;
+		}
+	}
+
+	void Graph::GetShortestPath(Node* node, vector<int>& path)
+	{
+		path.push_back(node->data);
+		if (node->parent != nullptr)
+		{
+			this->GetShortestPath(node->parent, path);
+		}
+	}
+
+	// Graph Public Member Methods
+	void Graph::PushDirectedEdge(int dataU, int dataV, int weight)
+	{
+		Node* nodeU = this->MakeOrFindNode(dataU);
+		Node* nodeV = this->MakeOrFindNode(dataV);
+
+		this->_adjlist[nodeU].push_back(nodeV);
+		this->_edgeMap[nodeU].push_back(new Edge(nodeU, nodeV, weight));
+	}
+
+	void Graph::FindDAGShortestPath(int data)
+	{
+		this->TopologicalSort();
+		Node* source = this->_nodeMap[data];
+		this->InitializeSingleSource(source);
+		for (auto& node : this->_topologicalSortedNodeList)
+		{
+			for (auto& edge : this->_edgeMap[node])
+			{
+				this->Relax(edge);
+			}
+		}
+	}
+
+	vector<int> Graph::GetDAGShortestPath(int data)
+	{
+		vector<int> path = {};
+		Node* node = this->_nodeMap[data];
+		this->GetShortestPath(node, path);
+		reverse(path.begin(), path.end());
+		return path;
+	}
+}

SourceCodes/0003_Graph/CMakeLists.txt

@@ -9,6 +9,7 @@ set(0003GRAPH_SOURCES
     0007_MinimumSpanningTreeKruskalAlgorithm.cc
     0008_MinimumSpanningTreePrimAlgorithm.cc
     0009_SingleSourceShortestPathBellmanFord.cc
+    0010_DirectedAcyclicGraphShortestPath.cc
 
 )
 

Tests/0003_Graph/0010_DirectedAcyclicGraphShortestPathTest.cc

@@ -21,6 +21,7 @@ add_executable(
   0007_MinimumSpanningTreeKruskalAlgorithmTest.cc
   0008_MinimumSpanningTreePrimAlgorithmTest.cc
   0009_SingleSourceShortestPathBellmanFordTest.cc
+  0010_DirectedAcyclicGraphShortestPathTest.cc
 )
 
 target_link_libraries(