From 1cbe6a7db976005ee64bbe38982702ca954aca03 Mon Sep 17 00:00:00 2001
From: Parth Patel <37498439+parth-15@users.noreply.github.com>
Date: Sat, 27 Oct 2018 11:31:17 +0530
Subject: [PATCH] Create SPFDAG

---
 SPFDAG | 143 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 143 insertions(+)
 create mode 100644 SPFDAG

diff --git a/SPFDAG b/SPFDAG
new file mode 100644
index 0000000..035e5b0
--- /dev/null
+++ b/SPFDAG
@@ -0,0 +1,143 @@
+
+// C++ program to find single source shortest paths for Directed Acyclic Graphs 
+#include<iostream> 
+#include <list> 
+#include <stack> 
+#include <limits.h> 
+#define INF INT_MAX 
+using namespace std; 
+  
+// Graph is represented using adjacency list. Every node of adjacency list  
+// contains vertex number of the vertex to which edge connects. It also  
+// contains weight of the edge 
+class AdjListNode 
+{ 
+    int v; 
+    int weight; 
+public: 
+    AdjListNode(int _v, int _w)  { v = _v;  weight = _w;} 
+    int getV()       {  return v;  } 
+    int getWeight()  {  return weight; } 
+}; 
+  
+// Class to represent a graph using adjacency list representation 
+class Graph 
+{ 
+    int V;    // No. of vertices' 
+  
+    // Pointer to an array containing adjacency lists 
+    list<AdjListNode> *adj; 
+  
+    // A function used by shortestPath 
+    void topologicalSortUtil(int v, bool visited[], stack<int> &Stack); 
+public: 
+    Graph(int V);   // Constructor 
+  
+    // function to add an edge to graph 
+    void addEdge(int u, int v, int weight); 
+  
+    // Finds shortest paths from given source vertex 
+    void shortestPath(int s); 
+}; 
+  
+Graph::Graph(int V) 
+{ 
+    this->V = V; 
+    adj = new list<AdjListNode>[V]; 
+} 
+  
+void Graph::addEdge(int u, int v, int weight) 
+{ 
+    AdjListNode node(v, weight); 
+    adj[u].push_back(node); // Add v to u's list 
+} 
+  
+// A recursive function used by shortestPath. See below link for details 
+// https://www.geeksforgeeks.org/topological-sorting/ 
+void Graph::topologicalSortUtil(int v, bool visited[], stack<int> &Stack) 
+{ 
+    // Mark the current node as visited 
+    visited[v] = true; 
+  
+    // Recur for all the vertices adjacent to this vertex 
+    list<AdjListNode>::iterator i; 
+    for (i = adj[v].begin(); i != adj[v].end(); ++i) 
+    { 
+        AdjListNode node = *i; 
+        if (!visited[node.getV()]) 
+            topologicalSortUtil(node.getV(), visited, Stack); 
+    } 
+  
+    // Push current vertex to stack which stores topological sort 
+    Stack.push(v); 
+} 
+  
+// The function to find shortest paths from given vertex. It uses recursive  
+// topologicalSortUtil() to get topological sorting of given graph. 
+void Graph::shortestPath(int s) 
+{ 
+    stack<int> Stack; 
+    int dist[V]; 
+  
+    // Mark all the vertices as not visited 
+    bool *visited = new bool[V]; 
+    for (int i = 0; i < V; i++) 
+        visited[i] = false; 
+  
+    // Call the recursive helper function to store Topological Sort 
+    // starting from all vertices one by one 
+    for (int i = 0; i < V; i++) 
+        if (visited[i] == false) 
+            topologicalSortUtil(i, visited, Stack); 
+  
+    // Initialize distances to all vertices as infinite and distance 
+    // to source as 0 
+    for (int i = 0; i < V; i++) 
+        dist[i] = INF; 
+    dist[s] = 0; 
+  
+    // Process vertices in topological order 
+    while (Stack.empty() == false) 
+    { 
+        // Get the next vertex from topological order 
+        int u = Stack.top(); 
+        Stack.pop(); 
+  
+        // Update distances of all adjacent vertices 
+        list<AdjListNode>::iterator i; 
+        if (dist[u] != INF) 
+        { 
+          for (i = adj[u].begin(); i != adj[u].end(); ++i) 
+             if (dist[i->getV()] > dist[u] + i->getWeight()) 
+                dist[i->getV()] = dist[u] + i->getWeight(); 
+        } 
+    } 
+  
+    // Print the calculated shortest distances 
+    for (int i = 0; i < V; i++) 
+        (dist[i] == INF)? cout << "INF ": cout << dist[i] << " "; 
+} 
+  
+// Driver program to test above functions 
+int main() 
+{ 
+    // Create a graph given in the above diagram.  Here vertex numbers are 
+    // 0, 1, 2, 3, 4, 5 with following mappings: 
+    // 0=r, 1=s, 2=t, 3=x, 4=y, 5=z 
+    Graph g(6); 
+    g.addEdge(0, 1, 5); 
+    g.addEdge(0, 2, 3); 
+    g.addEdge(1, 3, 6); 
+    g.addEdge(1, 2, 2); 
+    g.addEdge(2, 4, 4); 
+    g.addEdge(2, 5, 2); 
+    g.addEdge(2, 3, 7); 
+    g.addEdge(3, 4, -1); 
+    g.addEdge(4, 5, -2); 
+  
+    int s = 1; 
+    cout << "Following are shortest distances from source " << s <<" n"; 
+    g.shortestPath(s); 
+  
+    return 0; 
+}