Last Updated: 21 Dec, 2020

Topological Sort

Moderate

Asked in companies

Solve now

Problem statement

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

Solve now

Approaches

01 Approach

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.

Solve now

02 Approach

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’.

Solve now