Topological Sort Using DFS in DSA Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind Topological Sort using DFS?

We visit each node and explore all its descendants first using DFS. After visiting all descendants, we add the node to the result. This way, nodes appear after all nodes they depend on.

beginner

Why must the graph be a Directed Acyclic Graph (DAG) for Topological Sort?

Because if there is a cycle, there is no way to order nodes linearly without breaking dependencies. Topological sort only works if no cycles exist.

beginner

In Topological Sort using DFS, when do we add a node to the output list?

We add the node after visiting all its neighbors (descendants). This ensures all dependencies come before the node in the output.

intermediate

What data structure is commonly used to store the final topological order in DFS approach?

A stack or a list where nodes are appended after visiting all descendants. Reversing this list gives the topological order.

intermediate

How does DFS help detect cycles during Topological Sort?

By tracking nodes currently in the recursion stack (visiting state), if we revisit a node in this state, it means a cycle exists.

What type of graph is required for Topological Sort using DFS?

A Directed Acyclic Graph (DAG)

B Undirected Graph

C Graph with cycles

D Any graph

Topological sort only works on Directed Acyclic Graphs because cycles prevent a linear ordering.

When performing DFS for Topological Sort, when do we add a node to the output list?

A After visiting all neighbors

B Randomly

C When first discovered

D Before visiting neighbors

We add nodes after visiting all their neighbors to ensure dependencies come first.

What does it mean if during DFS we visit a node that is already in the recursion stack?

A The graph is disconnected

B The node is a leaf

C A cycle exists

D The node is already processed

Visiting a node in the recursion stack means a cycle, which breaks topological ordering.

Which data structure can be used to store nodes in order during DFS Topological Sort?

A Queue

B Stack

C Hash Map

D Set

A stack stores nodes after visiting descendants, reversing it gives the topological order.

What is the time complexity of Topological Sort using DFS on a graph with V vertices and E edges?

A O(V * E)

B O(V^2)

C O(E^2)

D O(V + E)

DFS visits each vertex and edge once, so time complexity is O(V + E).

Explain step-by-step how Topological Sort using DFS works on a Directed Acyclic Graph.

Think about visiting nodes and when to add them to the result.

How can DFS help detect cycles during Topological Sort and why is this important?

Focus on the states of nodes during DFS.

Practice

1. What is the main purpose of using DFS in Topological Sort on a directed graph?

easy

A. To visit nodes in a way that all dependencies come before the node itself

B. To find the shortest path between two nodes

C. To detect cycles in an undirected graph

D. To count the number of connected components

Solution

1. Step 1: Understand DFS role in Topological Sort

   DFS visits nodes deeply, ensuring all nodes reachable from a node are visited before the node itself.

2. Step 2: Relate DFS order to dependencies

   In Topological Sort, this means all dependencies (nodes with edges to current node) are processed before the node, preserving order.

3. Final Answer:

   To visit nodes in a way that all dependencies come before the node itself -> Option A

4. Quick Check:

   DFS ensures dependency order in Topological Sort [OK]

Hint: DFS visits dependencies before the node itself [OK]

Common Mistakes:

• Confusing DFS with BFS for topological order
• Thinking DFS finds shortest paths here
• Mixing cycle detection with topological sorting

2. Which of the following is the correct way to mark a node as visited in a DFS-based topological sort in Python?

easy

A. visited.add(node)

B. visited[node] == True

C. visited[node] = True

D. visited.append(node)

Solution

1. Step 1: Understand visited data structure type

   Usually, visited is a list or dictionary indexed by node, so marking visited means assigning True to that index.

2. Step 2: Identify correct syntax for assignment

   Using visited[node] = True correctly marks the node as visited. Using '==' is a comparison, not assignment.

3. Final Answer:

   visited[node] = True -> Option C

4. Quick Check:

   Assign True to visited[node] to mark visited [OK]

Hint: Use assignment (=), not comparison (==), to mark visited [OK]

Common Mistakes:

• Using '==' instead of '=' for assignment
• Using visited.append(node) when visited is a dict/list
• Using visited.add(node) when visited is not a set

3. What is the output of the following code snippet for topological sort using DFS?

graph = {0: [1, 2], 1: [2], 2: []}
visited = [False, False, False]
stack = []
def dfs(node):
    visited[node] = True
    for neighbor in graph[node]:
        if not visited[neighbor]:
            dfs(neighbor)
    stack.append(node)

for v in range(3):
    if not visited[v]:
        dfs(v)
print(stack[::-1])

medium

A. [0, 1, 2]

B. [2, 1, 0]

C. [1, 0, 2]

D. [2, 0, 1]

Solution

1. Step 1: Trace DFS calls and stack appends

   Start with node 0: visit 0, then neighbors 1 and 2. DFS(1) visits 1, then 2. DFS(2) visits 2, appends 2. Then append 1, then append 0.

2. Step 2: Reverse stack to get topological order

   Stack after DFS: [2, 1, 0]. Reversing gives [0, 1, 2].

3. Final Answer:

   [0, 1, 2] -> Option A

4. Quick Check:

   Stack reversed gives correct topological order [OK]

Hint: Reverse stack after DFS to get topological order [OK]

Common Mistakes:

• Not reversing the stack before printing
• Appending nodes before recursive DFS calls
• Confusing order of neighbors visited

4. Identify the error in this DFS-based topological sort code snippet:

def dfs(node):
    visited[node] = True
    for neighbor in graph[node]:
        if visited[neighbor]:
            dfs(neighbor)
    stack.append(node)

medium

A. DFS should not append nodes to stack

B. Stack should be cleared before DFS

C. Visited should be a set, not a list

D. The condition should be 'if not visited[neighbor]' before calling dfs

Solution

1. Step 1: Analyze the if condition in DFS

   The code calls dfs(neighbor) only if visited[neighbor] is True, which means neighbor was already visited. This causes repeated visits or infinite recursion.

2. Step 2: Correct the condition to avoid revisiting

   The condition should be 'if not visited[neighbor]' to visit unvisited neighbors only.

3. Final Answer:

   The condition should be 'if not visited[neighbor]' before calling dfs -> Option D

4. Quick Check:

   Visit neighbors only if not visited [OK]

Hint: Call dfs only on unvisited neighbors [OK]

Common Mistakes:

• Calling dfs on already visited nodes
• Not marking nodes visited before recursion
• Appending nodes to stack too early

5. Given a directed acyclic graph with edges: 5->2, 5->0, 4->0, 4->1, 2->3, 3->1, which of the following is a valid topological order using DFS-based topological sort?

hard

A. [1, 3, 2, 4, 5, 0]

B. [5, 4, 2, 3, 1, 0]

C. [0, 1, 2, 3, 4, 5]

D. [5, 2, 3, 1, 0, 4]

Solution

1. Step 1: Understand dependencies from edges

   Edges mean 5 before 2 and 0, 4 before 0 and 1, 2 before 3, 3 before 1. So 5 and 4 come before 2,3,1,0.

2. Step 2: Check each option for order validity

   [5, 4, 2, 3, 1, 0] respects all edges: 5 before 2 and 0, 4 before 0 and 1, 2 before 3, 3 before 1. Others violate these orders.

3. Final Answer:

   [5, 4, 2, 3, 1, 0] -> Option B

4. Quick Check:

   All edges respected in order [OK]

Hint: Check all edges respected in order for valid topological sort [OK]

Common Mistakes:

• Ignoring edge directions in order
• Assuming any order of nodes is valid
• Not verifying all dependencies before nodes