Topological Sort
A Directed Acyclic Graph (DAG) is a directed graph that contains no cycles.

Topological Sorting of DAG is a linear ordering of vertices such that for every directed edge from vertex ‘u’ to vertex ‘v’, vertex ‘u’ comes before ‘v’ in the ordering. Topological Sorting for a graph is not possible if the graph is not a DAG.

Given a DAG consisting of ‘V’ vertices and ‘E’ edges, you need to find out any topological sorting of this DAG. Return an array of size ‘V’ representing the topological sort of the vertices of the given DAG.

For example, Consider the DAG shown in the picture.

In this graph, there are directed edges from 0 to 1 and 0 to 3, so 0 should come before 1 and 3. Also, there are directed edges from 1 to 2 and 3 to 2 so 1 and 3 should come before 2.

So, The topological sorting of this DAG is {0 1 3 2}.

Note that there are multiple topological sortings possible for a DAG. For the graph given above one another topological sorting is: {0, 3, 1, 2}

Note:

1. It is guaranteed that the given graph is DAG. 2. There will be no multiple edges and self-loops in the given DAG. 3. There can be multiple correct solutions, you can find any one of them. 4. Don’t print anything, just return an array representing the topological sort of the vertices of the given DAG.

Input format:

The first line of input contains an integer ‘T’ denoting the number of test cases. The description of ‘T’ test cases follows. The first line of each test case contains two space-separated integers ‘V’, ‘E’, representing the number vertices and edges in the graph respectively. Then ‘E’ lines follow, each containing 2 space-separated integers ‘u’, ‘v’ representing that there is a directed edge from vertex ‘u’ to vertex ‘v’

Output format :

For each test case, return an array representing the topological sort of the vertices of the given DAG.

Note :

You do not need to print anything. It has already been taken care of. Just implement the given function.

Constraints:

1

Question

Topological Sort

A Directed Acyclic Graph (DAG) is a directed graph that contains no cycles.

Topological Sorting of DAG is a linear ordering of vertices such that for every directed edge from vertex ‘u’ to vertex ‘v’, vertex ‘u’ comes before ‘v’ in the ordering. Topological Sorting for a graph is not possible if the graph is not a DAG.

Given a DAG consisting of ‘V’ vertices and ‘E’ edges, you need to find out any topological sorting of this DAG. Return an array of size ‘V’ representing the topological sort of the vertices of the given DAG.

For example, Consider the DAG shown in the picture.

alt tex

In this graph, there are directed edges from 0 to 1 and 0 to 3, so 0 should come before 1 and 3. Also, there are directed edges from 1 to 2 and 3 to 2 so 1 and 3 should come before 2.

So, The topological sorting of this DAG is {0 1 3 2}.

Note that there are multiple topological sortings possible for a DAG. For the graph given above one another topological sorting is: {0, 3, 1, 2}

Note:

1. It is guaranteed that the given graph is DAG.
2. There will be no multiple edges and self-loops in the given DAG.
3. There can be multiple correct solutions, you can find any one of them. 
4. Don’t print anything, just return an array representing the topological sort of the vertices of the given DAG.

Input format:

The first line of input contains an integer ‘T’ denoting the number of test cases. The description of  ‘T’ test cases follows.

The first line of each test case contains two space-separated integers ‘V’, ‘E’, representing the number vertices and edges in the graph respectively.

Then ‘E’ lines follow,  each containing 2 space-separated integers ‘u’, ‘v’ representing that there is a directed edge from vertex ‘u’ to vertex ‘v’

Output format :

For each test case, return an array representing the topological sort of the vertices of the given DAG.

Note :

You do not need to print anything. It has already been taken care of. Just implement the given function.

Constraints:

1 <= T <= 50
1 <= V <= 10^4
0 <= E <= 10^4
0 <= u, v < V 

Where ‘T’ is the total number of test cases, ‘V’ is the number of vertices, ‘E’ is the number of edges, and ‘u’ and ‘v’ both represent the vertex of a given graph.

Time limit: 2 sec

Accepted Answer

Topological sorting of vertices of a Directed Acyclic Graph is an ordering of the vertices v1,v2,v3.....vn in such a way, that if there is an edge directed towards vertex vj from vertex vi , then vi comes before vj. Modified DFS can be used to solve topological sort problem. A stack can be used to implement it. Steps :
1. Make a stack to store the nodes and a Boolean array to mark all visited nodes initialized to false.
2. Now, create a recursive helper function and call it for every unvisited node to store Topological Sort starting from all vertices one by one.
3. In the helper function, mark the current node as visited and recur for all the unvisited vertices adjacent to this vertex. At last, Push current vertex to stack which stores result.
4. After all the nodes are processed, print the contents of the stack.
Time Complexity : O(V+E)
Space Complexity : O(V)

Accepted Answer

Modify Depth First Search

In the Depth First Search (DFS), we start from a vertex, we first print it and then recursively call DFS for its adjacent vertices. In topological sorting, we use a stack. We don’t print the vertex immediately, we first recursively call topological sorting for all its adjacent vertices, then push it to a stack. Finally, print contents of the stack. Note that a vertex is pushed to stack only when all of its adjacent vertices (and their adjacent vertices and so on) are already in the stack.

This is a recursive approach.
Make an adjacency list of the given graph.
Make a boolean array ‘visited’ of size ‘V’ and initially fill it by ‘false’. This will keep track of the vertex that is already visited.
Make a stack that will keep topological sorting of vertices in the top to bottom order.
Run a loop where ‘i’ ranges from 0 to V-1. For each vertex ‘i’ which is not already visited, we will call a recursive function that will perform the following steps -:
- Mark the current vertex ‘i’ visited by setting ‘visited[i]’:= true.
- Iterate over all the adjacent vertices of ‘i’ that are not already visited and recursively call this function.
- Push vertex ‘i’ in the stack.
Make a vector ‘result’ and push all the elements of the stack in it from top to bottom.
Return the vector ‘result’, It will represent topological sorting of given DAG.

Space Complexity: O(n)Explanation:

O(V), where ‘V’ is the number of vertices.

The size of the stack and ‘result’ array both will be of the order of ‘V’.

Time Complexity: OtherExplanation:

O(V + E), where ‘V’ is the number of vertices and ‘E’ is the number of edges.

The above algorithm is simply DFS with an extra stack. So time complexity is the same as DFS.

Accepted Answer

Kahn’s Algorithm

The Kahn’s Algorithm can be implemented as follow -:

Make adjacency list of the given graph
Make an integer array ‘indegree’ of size ‘V’ that will store indegree (number of incoming edges to the vertex) of all vertices.
Iterate over the edges and compute indegree of all vertices.
Make a queue and enqueue all vertices that have in-degree 0.
Make a vector ‘result’ that will store topological sorting of the given DAG.
Run a while loop till queue not become empty and in each iteration perform following steps -:
- Dequeue the front element of the queue, and push it into the ‘result vector.
- Decrease in-degree by 1 for all its neighbouring vertices.
- If the in-degree of a neighbouring vertex is reduced to zero, then add it to the queue.
Return ‘result’.