Course Schedule

Easy
0/40
Average time to solve is 15m
39 upvotes
Asked in companies
UberPaytm (One97 Communications Limited)Apple

Problem statement

You are a student of Netaji Subhas Institute of Technology. You have to take ‘N’ number of courses labelled from 1 to N to complete your B.Tech Degree.

Some courses may have prerequisites, for example, to take course 1 you have to first take course 2, which is expressed as a pair: [1, 2]. Now, your task is to find is it possible for you to finish all courses.

Note: There are no duplicate pairs in the prerequisites array.

For example-
If N = 2 and prerequisite = [[1, 2]]. Then, there are a total of 2 courses you need to take. To take course 1 you need to finish course 2. So, it is possible to complete all courses. 
Detailed explanation ( Input/output format, Notes, Images )
Input Format:
The first line contains an integer 'T' which denotes the number of test cases or queries to be run. Then the test cases follow.

The first line of each test case contains two space-separated integers ‘N’ and ‘M’ representing the total number of courses and the total number of prerequisites, respectively.

From the second line of each test case, the next M lines represent the prerequisites for courses. Every line contains two single space-separated integers representing a prerequisite pair.
Output Format:
For each test case, the only line of output will print “Yes” if you can complete the courses. Else print “No”.

Print the output of each test case in a separate line.

Note:
You are not required to print the expected output, it has already been taken care of. Just implement the function.
Constraints:
1 <= T <= 10
1 <= N <= 5000
0 <= M <= min(5000, (N * (N - 1)) / 2)
1 <= prerequisites[i][0] <= N 
1 <= prerequisites[i][1] <= N 

Time Limit: 1 sec 
Sample Input 1:
1
3 2
1 2
2 1
Sample output 1:
No
Explanation of Sample output 1:
There are a total of 3 courses you need to take. To take course 1 you need to finish course 2. To take course 2 you need to finish course 1. So, it is impossible to complete all courses. 
Sample Input 2:
2
4 0 
4 2
1 2
2 3
Sample output 2:
Yes
Yes
Hint

Try to consider the problem as a graph problem.

Approaches (2)
DFS Approach

The key observation here is that we need to consider the number of courses as vertices of a graph and prerequisites as directed edges of a graph.

 

Now the problem boils down to find if a cycle exists in the directed graph or not. If a cycle exists, no topological ordering exists and therefore it is impossible to take all courses.

 

Now, there is a cycle in the graph only if there is a back edge present in the graph. To detect a back edge, we will keep track of vertices currently in the recursion stack of function for DFS traversal. If a vertex is reached that is already in the recursion stack, then there is a cycle in the graph. 

 

Here is the complete algorithm:

  1. Create a graph using the ‘prerequisites’ array.
  2. We initialise two arrays of ‘visited’ and ‘recursionStack’ to keep track of the visited vertices and vertices that are currently in the recursion stack,  respectively.
  3. We iterate over all vertices of the graph and if the vertex is unvisited, we call the ‘isCycle’ function from that vertex. The ‘isCycle’ function works as follows:
    1. Mark the current vertex true in the ‘visited’ and ‘recursionStack’ array.
    2. Find all the adjacent vertices of the current vertex
      1. If an adjacent vertex is not visited
        1. Recursively call the ‘isCycle’ function for the adjacent vertex.
        2. If the recursive function returns true, then return true.
      2. Else if adjacent vertex is already visited and already marked in the ‘recursionStack’ array.
        1. Return true.
    3. Finally, unmark the vertex from the ‘recursionStack’ array and return false.
  4. If the ‘isCycle’ function returns true, then return “No”.
  5. Finally, return “Yes”.
Time Complexity

O(N + M), where N is the number of vertices and M is the number of edges in the graph.

 

In the worst case, we are visiting each vertex and edge of the graph only once. Hence, the time complexity is O(N + M).

Space Complexity

O(N), where N is the number of vertices in the graph.

 

Since we are using an extra array to keep track of visited vertices and in the worst case, we have all the vertices of the graph in the recursion stack. Hence, the space complexity is O(N). 

Code Solution
(100% EXP penalty)
Course Schedule
Full screen
Console