Why Topological Sort Using DFS in DSA Go?

The Big Idea

What if you could instantly find the perfect order to finish all your tasks without any confusion or mistakes?

The Scenario

Imagine you have a list of tasks to do, but some tasks must be done before others. For example, you must bake a cake before you can decorate it. If you try to figure out the order by writing down all possibilities on paper, it quickly becomes confusing and messy.

The Problem

Trying to manually find the correct order of tasks is slow and easy to mess up. You might forget a dependency or create a cycle where tasks depend on each other endlessly. This makes it hard to know which task to do first.

The Solution

Topological Sort using DFS helps by automatically finding a correct order to do tasks when some depend on others. It explores each task deeply, making sure all its prerequisites are done first, then adds the task to the order. This way, you get a clear, correct sequence without guessing.

Before vs After

✗ Before

tasks := []string{"Bake cake", "Decorate cake", "Buy ingredients"}
// Manually trying to order tasks by checking dependencies one by one

✓ After

func topologicalSort(tasks map[string][]string) []string {
    // Use DFS to find correct order automatically
    var result []string
    visited := make(map[string]bool)
    var dfs func(string)
    dfs = func(task string) {
        if visited[task] {
            return
        }
        visited[task] = true
        for _, prereq := range tasks[task] {
            dfs(prereq)
        }
        result = append(result, task)
    }
    for task := range tasks {
        dfs(task)
    }
    // Reverse result to get correct order
    for i, j := 0, len(result)-1; i < j; i, j = i+1, j-1 {
        result[i], result[j] = result[j], result[i]
    }
    return result
}

What It Enables

This lets you automatically find a safe order to complete tasks or steps that depend on each other, avoiding mistakes and saving time.

Real Life Example

Planning a project where some jobs must finish before others start, like building a house: foundation before walls, walls before roof. Topological sort helps schedule these jobs correctly.

Key Takeaways

Manual ordering of dependent tasks is confusing and error-prone.

Topological sort with DFS finds a correct order by exploring dependencies deeply.

This method helps plan tasks or steps that must happen in a specific sequence.

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 ensures dependencies come before dependents

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 dependencies of a node are visited before the node itself.

2. Step 2: Relate DFS order to dependencies

   By pushing nodes to a stack after visiting all neighbors, we get an order where dependencies come before dependents.

3. Final Answer:

   To visit nodes in a way that ensures dependencies come before dependents -> Option A

4. Quick Check:

   DFS ensures dependency order = A [OK]

Hint: DFS post-order gives correct dependency order [OK]

Common Mistakes:

• Confusing DFS with BFS for topological sort
• Thinking topological sort finds shortest paths
• Assuming DFS detects cycles in undirected graphs here

2. Which of the following Go code snippets correctly declares a recursive DFS function for topological sort?

easy

A. func dfs(node int, graph map[int][]int, visited map[int]bool, stack *[]int) { if visited[node] { return } visited[node] = true *stack = append(*stack, node) for _, neighbor := range graph[node] { dfs(neighbor, graph, visited, stack) } }

B. func dfs(node int, graph map[int][]int, visited map[int]bool, stack []int) { if visited[node] { return } visited[node] = true for _, neighbor := range graph[node] { dfs(neighbor, graph, visited, stack) } stack = append(stack, node) }

C. func dfs(node int, graph map[int][]int, visited map[int]bool, stack *[]int) { if visited[node] { return } for _, neighbor := range graph[node] { dfs(neighbor, graph, visited, stack) } visited[node] = true *stack = append(*stack, node) }

D. func dfs(node int, graph map[int][]int, visited map[int]bool, stack *[]int) { if !visited[node] { visited[node] = true for _, neighbor := range graph[node] { dfs(neighbor, graph, visited, stack) } *stack = append(*stack, node) } }

Solution

1. Step 1: Check visited condition and marking

   func dfs(node int, graph map[int][]int, visited map[int]bool, stack *[]int) { if !visited[node] { visited[node] = true for _, neighbor := range graph[node] { dfs(neighbor, graph, visited, stack) } *stack = append(*stack, node) } } correctly checks if node is not visited before processing and marks it visited inside the condition.

2. Step 2: Confirm stack append and recursion

   It recursively calls dfs on neighbors and appends node to stack after visiting neighbors, using pointer to modify stack.

3. Final Answer:

   Option D code snippet -> Option D

4. Quick Check:

   Correct DFS recursion and stack append = D [OK]

Hint: Use pointer for stack to append in recursive DFS [OK]

Common Mistakes:

• Passing stack by value causing no changes
• Marking visited after recursion causing repeated visits
• Appending node before visiting neighbors

3. What is the output order of nodes after performing topological sort using DFS on this graph?

graph := map[int][]int{
  5: {2, 0},
  4: {0, 1},
  2: {3},
  3: {1},
  0: {},
  1: {},
}

Assuming DFS visits nodes in ascending order starting from 5, then 4.

medium

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

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

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

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

Solution

1. Step 1: Perform DFS starting from node 5

   DFS from 5 (neighbors ascending: 0 then 2): DFS(0) append 0; then DFS(2) -> DFS(3) -> DFS(1) append 1; append 3; append 2; append 5. Then DFS from 4 (0,1 visited), append 4.

2. Step 2: Collect nodes in post-order (append after visiting neighbors)

   Post-order stack push order: 0, 1, 3, 2, 5, 4. Reversing gives [4, 5, 2, 3, 1, 0].

3. Step 3: Consider DFS starting order and visited nodes

   Since DFS visits 5 first, then 4, the final topological order is the reverse of the post-order stack: [4, 5, 2, 3, 1, 0]. However, the question states DFS visits nodes in ascending order starting from 5, then 4. The actual post-order stack is [0,1,3,2,5,4], so reversed order is [4,5,2,3,1,0].

4. Final Answer:

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

5. Quick Check:

   Post-order reverse = [4,5,2,3,1,0] [OK]

Hint: Reverse DFS post-order for topological sort output [OK]

Common Mistakes:

• Not reversing the stack after DFS
• Visiting nodes in wrong order
• Ignoring already visited nodes

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

func dfs(node int, graph map[int][]int, visited map[int]bool, stack *[]int) {
  if visited[node] {
    return
  }
  for _, neighbor := range graph[node] {
    dfs(neighbor, graph, visited, stack)
  }
  visited[node] = true
  *stack = append(*stack, node)
}

medium

A. Visited is marked after recursion, causing repeated visits

B. Stack is appended before visiting neighbors

C. Visited map is not initialized

D. Function does not return any value

Solution

1. Step 1: Check visited marking timing

   Visited is marked after recursive calls, so neighbors may revisit the same node multiple times.

2. Step 2: Correct visited marking position

   Visited should be marked before recursion to avoid repeated visits and infinite loops.

3. Final Answer:

   Visited is marked after recursion, causing repeated visits -> Option A

4. Quick Check:

   Mark visited before recursion = B [OK]

Hint: Mark visited before recursion to avoid repeats [OK]

Common Mistakes:

• Marking visited too late causing infinite recursion
• Appending stack before recursion
• Ignoring initialization of visited map

5. Given a directed graph with edges:

1 -> 2, 1 -> 3, 3 -> 4, 2 -> 4, 4 -> 5

If you want to find a valid order to complete tasks represented by nodes, which topological sort order is correct?

hard

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

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

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

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

Solution

1. Step 1: Analyze dependencies from edges

   Node 1 must come before 2 and 3; 2 and 3 before 4; 4 before 5.

2. Step 2: Find order respecting dependencies

   Order [1, 2, 3, 4, 5] respects all edges: 1 before 2 and 3, 2 and 3 before 4, 4 before 5.

3. Final Answer:

   [1, 2, 3, 4, 5] -> Option C

4. Quick Check:

   Dependencies respected = C [OK]

Hint: Start with nodes having no incoming edges [OK]

Common Mistakes:

• Reversing order ignoring dependencies
• Placing dependent before dependency
• Choosing order with cycles