added Dijkstra's Algorithm

C++program/DijkstraAlgorithm.cpp

@@ -0,0 +1,153 @@
+/*
+Dijkstra’s shortest path algorithm for Adjacency List using Heap in O(E logV):
+
+For Dijkstra’s algorithm, it is always recommended to use Heap (or priority queue) as the required operations (extract minimum and decrease key) match with the specialty of the heap (or priority queue). However, the problem is, that priority_queue doesn’t support the decrease key. To resolve this problem, do not update a key, but insert one more copy of it. So we allow multiple instances of the same vertex in the priority queue. This approach doesn’t require decreasing key operations and has below important properties.
+
+    Whenever the distance of a vertex is reduced, we add one more instance of a vertex in priority_queue. Even if there are multiple instances, we only consider the instance with minimum distance and ignore other instances.
+    The time complexity remains O(E * LogV) as there will be at most O(E) vertices in the priority queue and O(logE) is the same as O(logV)
+
+Below is the implementation of the above approach:
+*/
+
+// C++ Program to find Dijkstra's shortest path using
+// priority_queue in STL
+#include <bits/stdc++.h>
+using namespace std;
+#define INF 0x3f3f3f3f
+
+// iPair ==> Integer Pair
+typedef pair<int, int> iPair;
+
+// This class represents a directed graph using
+// adjacency list representation
+class Graph {
+	int V; // No. of vertices
+
+	// In a weighted graph, we need to store vertex
+	// and weight pair for every edge
+	list<pair<int, int> >* adj;
+
+public:
+	Graph(int V); // Constructor
+
+	// function to add an edge to graph
+	void addEdge(int u, int v, int w);
+
+	// prints shortest path from s
+	void shortestPath(int s);
+};
+
+// Allocates memory for adjacency list
+Graph::Graph(int V)
+{
+	this->V = V;
+	adj = new list<iPair>[V];
+}
+
+void Graph::addEdge(int u, int v, int w)
+{
+	adj[u].push_back(make_pair(v, w));
+	adj[v].push_back(make_pair(u, w));
+}
+
+// Prints shortest paths from src to all other vertices
+void Graph::shortestPath(int src)
+{
+	// Create a priority queue to store vertices that
+	// are being preprocessed. This is weird syntax in C++.
+	// Refer below link for details of this syntax
+	// https://www.geeksforgeeks.org/implement-min-heap-using-stl/
+	priority_queue<iPair, vector<iPair>, greater<iPair> >
+		pq;
+
+	// Create a vector for distances and initialize all
+	// distances as infinite (INF)
+	vector<int> dist(V, INF);
+
+	// Insert source itself in priority queue and initialize
+	// its distance as 0.
+	pq.push(make_pair(0, src));
+	dist[src] = 0;
+
+	/* Looping till priority queue becomes empty (or all
+	distances are not finalized) */
+	while (!pq.empty()) {
+		// The first vertex in pair is the minimum distance
+		// vertex, extract it from priority queue.
+		// vertex label is stored in second of pair (it
+		// has to be done this way to keep the vertices
+		// sorted distance (distance must be first item
+		// in pair)
+		int u = pq.top().second;
+		pq.pop();
+
+		// 'i' is used to get all adjacent vertices of a
+		// vertex
+		list<pair<int, int> >::iterator i;
+		for (i = adj[u].begin(); i != adj[u].end(); ++i) {
+			// Get vertex label and weight of current
+			// adjacent of u.
+			int v = (*i).first;
+			int weight = (*i).second;
+
+			// If there is shorted path to v through u.
+			if (dist[v] > dist[u] + weight) {
+				// Updating distance of v
+				dist[v] = dist[u] + weight;
+				pq.push(make_pair(dist[v], v));
+			}
+		}
+	}
+
+	// Print shortest distances stored in dist[]
+	printf("Vertex Distance from Source\n");
+	for (int i = 0; i < V; ++i)
+		printf("%d \t\t %d\n", i, dist[i]);
+}
+
+// Driver's code
+int main()
+{
+	// create the graph given in above figure
+	int V = 9;
+	Graph g(V);
+
+	// making above shown graph
+	g.addEdge(0, 1, 4);
+	g.addEdge(0, 7, 8);
+	g.addEdge(1, 2, 8);
+	g.addEdge(1, 7, 11);
+	g.addEdge(2, 3, 7);
+	g.addEdge(2, 8, 2);
+	g.addEdge(2, 5, 4);
+	g.addEdge(3, 4, 9);
+	g.addEdge(3, 5, 14);
+	g.addEdge(4, 5, 10);
+	g.addEdge(5, 6, 2);
+	g.addEdge(6, 7, 1);
+	g.addEdge(6, 8, 6);
+	g.addEdge(7, 8, 7);
+
+	// Function call
+	g.shortestPath(0);
+
+	return 0;
+}
+
+/*
+Output
+
+Vertex Distance from Source
+0          0
+1          4
+2          12
+3          19
+4          21
+5          11
+6          9
+7          8
+8          14
+
+Time Complexity: O(E * logV), Where E is the number of edges and V is the number of vertices.
+Auxiliary Space: O(V)
+*/

C++program/topologicalsort.cpp

@@ -0,0 +1,113 @@
+/*
+Topological sorting for Directed Acyclic Graph (DAG) is a linear ordering of vertices such that for every directed edge uv, 
+vertex u comes before v in the ordering. 
+Topological Sorting for a graph is not possible if the graph is not a DAG. For example, a topological sorting of the following graph is “5 4 2 3 1 0”. 
+There can be more than one topological sorting for a graph. For example, another topological sorting of the following graph is “4 5 2 3 1 0”.
+The first vertex in topological sorting is always a vertex with in-degree as 0 (a vertex with no in-coming edges).
+*/
+
+// A C++ program to print topological sorting of a DAG
+#include <iostream>
+#include <list>
+#include <stack>
+using namespace std;
+
+// Class to represent a graph
+class Graph {
+	int V; // No. of vertices'
+
+	// Pointer to an array containing adjacency listsList
+	list<int>* adj;
+
+	// A function used by topologicalSort
+	void topologicalSortUtil(int v, bool visited[], stack<int>& Stack);
+
+public:
+	Graph(int V); // Constructor
+
+	// function to add an edge to graph
+	void addEdge(int v, int w);
+
+	// prints a Topological Sort of the complete graph
+	void topologicalSort();
+};
+
+Graph::Graph(int V)
+{
+	this->V = V;
+	adj = new list<int>[V];
+}
+
+void Graph::addEdge(int v, int w)
+{
+	adj[v].push_back(w); // Add w to v’s list.
+}
+
+// A recursive function used by topologicalSort
+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<int>::iterator i;
+	for (i = adj[v].begin(); i != adj[v].end(); ++i)
+		if (!visited[*i])
+			topologicalSortUtil(*i, visited, Stack);
+
+	// Push current vertex to stack which stores result
+	Stack.push(v);
+}
+
+// The function to do Topological Sort. It uses recursive
+// topologicalSortUtil()
+void Graph::topologicalSort()
+{
+	stack<int> Stack;
+
+	// 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);
+
+	// Print contents of stack
+	while (Stack.empty() == false) {
+		cout << Stack.top() << " ";
+		Stack.pop();
+	}
+}
+
+// Driver program to test above functions
+int main()
+{
+	// Create a graph given in the above diagram
+	Graph g(6);
+	g.addEdge(5, 2);
+	g.addEdge(5, 0);
+	g.addEdge(4, 0);
+	g.addEdge(4, 1);
+	g.addEdge(2, 3);
+	g.addEdge(3, 1);
+
+	cout << "Following is a Topological Sort of the given graph: ";
+	g.topologicalSort();
+
+	return 0;
+}
+
+/*
+Output
+
+Following is a Topological Sort of the given graph: 5 4 2 3 1 0 
+
+Time Complexity: O(V+E). The above algorithm is simply DFS with an extra stack. So time complexity is the same as DFS
+Auxiliary space: O(V). The extra space is needed for the stack
+
+*/