Topological Sort Using Kahn's Algorithm BFS in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the in-degree vector with zeros for each node.

DSA Rust

let mut in_degree = vec![[1]; num_nodes];

Drag options to blanks, or click blank then click option'

Avec

B1

Cnum_nodes

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing with ones instead of zeros.

Using num_nodes as the initial value instead of zero.

The in-degree vector should be initialized with zeros for all nodes before counting edges.

2fill in blank

medium

Complete the code to push nodes with zero in-degree into the queue.

DSA Rust

for node in 0..num_nodes {
    if in_degree[node] == [1] {
        queue.push_back(node);
    }
}

Drag options to blanks, or click blank then click option'

A0

B1

Cnum_nodes

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Checking for in-degree equal to one instead of zero.

Using negative values which are invalid for in-degree.

Nodes with zero in-degree have no dependencies and should be added to the queue first.

3fill in blank

hard

Fix the error in the code that decreases the in-degree of adjacent nodes.

DSA Rust

for &adj in &graph[node] {
    in_degree[adj] [1] 1;
    if in_degree[adj] == 0 {
        queue.push_back(adj);
    }
}

Drag options to blanks, or click blank then click option'

A-=

B+=

C*=

D/=

Attempts:

3 left

💡 Hint

Common Mistakes

Using += which increases in-degree incorrectly.

Using multiplication or division operators which are not relevant here.

We decrease the in-degree of adjacent nodes by 1 when we remove an edge.

4fill in blank

hard

Fill both blanks to correctly build the adjacency list and update in-degree counts.

DSA Rust

for &(src, dest) in edges.iter() {
    graph[[1]].push( [2] );
    in_degree[dest] += 1;
}

Drag options to blanks, or click blank then click option'

Asrc

Bdest

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping source and destination nodes in adjacency list.

Increasing in-degree of the wrong node.

The adjacency list is built by adding destination nodes to the source node's list. The in-degree of the destination node increases by 1.

5fill in blank

hard

Fill all three blanks to complete the main loop that processes nodes in topological order.

DSA Rust

while let Some(node) = queue.pop_front() {
    topo_order.push(node);
    for &adj in &graph[[1]] {
        in_degree[[2]] [3] 1;
        if in_degree[adj] == 0 {
            queue.push_back(adj);
        }
    }
}

Drag options to blanks, or click blank then click option'

Anode

Badj

C-=

D+=

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong variable names for indexing.

Increasing in-degree instead of decreasing.

We process the current node, then for each adjacent node, decrease its in-degree by 1. If in-degree becomes zero, add it to the queue.

Practice

1. What is the main purpose of Kahn's Algorithm in graph theory?

easy

A. To find a topological ordering of a Directed Acyclic Graph (DAG)

B. To find the shortest path between two nodes

C. To detect cycles in an undirected graph

D. To calculate the minimum spanning tree

Solution

1. Step 1: Understand Kahn's Algorithm goal

   Kahn's Algorithm is designed to produce a linear ordering of vertices in a Directed Acyclic Graph (DAG) such that for every directed edge uv, vertex u comes before v in the ordering.

2. Step 2: Compare with other graph algorithms

   Shortest path algorithms find paths, cycle detection checks for loops, and minimum spanning tree algorithms work on undirected graphs. Kahn's Algorithm specifically produces a topological order.

3. Final Answer:

   To find a topological ordering of a Directed Acyclic Graph (DAG) -> Option A

4. Quick Check:

   Topological sort = Kahn's Algorithm purpose [OK]

Hint: Kahn's Algorithm always orders DAG nodes topologically [OK]

Common Mistakes:

• Confusing topological sort with shortest path
• Thinking it detects cycles in undirected graphs
• Mixing it with minimum spanning tree algorithms

2. Which Rust data structure is best suited to keep track of nodes with zero incoming edges in Kahn's Algorithm?

easy

A. HashMap

B. VecDeque (double-ended queue)

C. BinaryHeap

D. LinkedList

Solution

1. Step 1: Identify the need for queue behavior

   Kahn's Algorithm processes nodes with zero incoming edges in FIFO order, so a queue is needed to efficiently pop from front and push at back.

2. Step 2: Choose the Rust data structure

   VecDeque provides efficient push and pop operations at both ends, making it ideal for queue operations. HashMap is for key-value storage, BinaryHeap is a priority queue, and LinkedList is less efficient in Rust.

3. Final Answer:

   VecDeque (double-ended queue) -> Option B

4. Quick Check:

   Queue for zero in-degree nodes = VecDeque [OK]

Hint: Use VecDeque for queue operations in Rust [OK]

Common Mistakes:

• Using HashMap instead of a queue
• Choosing BinaryHeap which is a priority queue
• Using LinkedList which is inefficient in Rust

3. Given the following Rust code snippet implementing Kahn's Algorithm, what will be the printed topological order?

let edges = vec![(0, 1), (0, 2), (1, 3), (2, 3)];
let n = 4;
// Assume graph and in_degree are built correctly
// After running Kahn's Algorithm, the order vector is printed
println!("{:?}", order);

medium

A. [0, 1, 2, 3]

B. [3, 1, 2, 0]

C. [0, 2, 1, 3]

D. [1, 0, 2, 3]

Solution

1. Step 1: Analyze the graph edges and in-degree

   Edges: 0->1, 0->2, 1->3, 2->3. Node 0 has in-degree 0, nodes 1 and 2 have in-degree 1, node 3 has in-degree 2.

2. Step 2: Perform Kahn's Algorithm BFS

   Start with node 0 (in-degree 0). Remove it, reduce in-degree of 1 and 2 to 0. Add 1 and 2 to queue. Next, remove 1, then 2, then 3. Order is [0, 1, 2, 3]. However, since nodes 1 and 2 become zero in-degree simultaneously, the order of processing them can vary. If we process 2 before 1, the order is [0, 2, 1, 3], which is also valid.

3. Final Answer:

   [0, 2, 1, 3] -> Option C

4. Quick Check:

   Topological order respects edges = [0, 2, 1, 3] [OK]

Hint: Start with zero in-degree nodes and process neighbors [OK]

Common Mistakes:

• Reversing order of nodes processed
• Ignoring in-degree updates
• Assuming multiple valid orders without checking edges

4. Identify the bug in this Rust snippet of Kahn's Algorithm:

for &node in &graph[node] {
    in_degree[node] -= 1;
    if in_degree[node] == 0 {
        queue.push_back(node);
    }
}

medium

A. Missing initialization of in_degree array

B. Should use 'queue.push_front' instead of 'push_back'

C. Queue should be a stack for correct order

D. Using 'node' as loop variable shadows outer 'node', causing wrong indexing

Solution

1. Step 1: Understand variable shadowing in the loop

   The loop uses 'node' as the loop variable, which shadows the outer 'node' variable used to index graph. This causes confusion and incorrect indexing.

2. Step 2: Correct the variable naming

   Use a different variable name like 'neighbor' in the loop to avoid shadowing and correctly access neighbors.

3. Final Answer:

   Using 'node' as loop variable shadows outer 'node', causing wrong indexing -> Option D

4. Quick Check:

   Variable shadowing causes bugs = Using 'node' as loop variable shadows outer 'node', causing wrong indexing [OK]

Hint: Avoid reusing variable names in nested loops [OK]

Common Mistakes:

• Ignoring variable shadowing
• Confusing queue with stack usage
• Assuming in_degree initialization is the bug

5. You have a graph with edges: [(5, 2), (5, 0), (4, 0), (4, 1), (2, 3), (3, 1)]. Using Kahn's Algorithm, which of the following is a valid topological order?

hard

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

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

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

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

Solution

1. Step 1: Calculate in-degree for each node

   Nodes: 0,1,2,3,4,5 In-degree: 0(2), 1(2), 2(1), 3(1), 4(0), 5(0)

2. Step 2: Perform Kahn's Algorithm steps

   Start with nodes 4 and 5 (in-degree 0). Remove 5: reduce in-degree of 2 and 0. Remove 4: reduce in-degree of 0 and 1. Then remove 2, 3, 1, 0 in order. One valid order is [5, 4, 2, 3, 1, 0].

3. Final Answer:

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

4. Quick Check:

   Valid topological order respects edges = [5, 4, 2, 3, 1, 0] [OK]

Hint: Start with zero in-degree nodes and remove edges stepwise [OK]

Common Mistakes:

• Choosing orders that violate edge directions
• Ignoring initial zero in-degree nodes
• Mixing node order without updating in-degree