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

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the in-degree array for all vertices.

DSA C#

int[] inDegree = new int[graph.Length];
for (int i = 0; i < graph.Length; i++) {
    foreach (int neighbor in graph[i]) {
        inDegree[[1]]++;
    }
}

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

Ai

B0

Cgraph

Dneighbor

Attempts:

3 left

💡 Hint

Common Mistakes

Incrementing inDegree[i] instead of inDegree[neighbor]

Using graph instead of neighbor as index

We increase the in-degree of each neighbor vertex because it has an incoming edge from vertex i.

2fill in blank

medium

Complete the code to enqueue all vertices with zero in-degree.

DSA C#

Queue<int> queue = new Queue<int>();
for (int i = 0; i < inDegree.Length; i++) {
    if (inDegree[i] == [1]) {
        queue.Enqueue(i);
    }
}

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

A1

B0

CinDegree[i]

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Checking for inDegree[i] == 1 instead of 0

Using inDegree[i] directly in the if condition without comparison

Vertices with zero in-degree have no dependencies and can be processed first.

3fill in blank

hard

Fix the error in the loop that processes neighbors and updates in-degree.

DSA C#

while (queue.Count > 0) {
    int vertex = queue.Dequeue();
    result.Add(vertex);
    foreach (int neighbor in graph[vertex]) {
        inDegree[[1]]--;
        if (inDegree[neighbor] == 0) {
            queue.Enqueue(neighbor);
        }
    }
}

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

Aneighbor

Bvertex

Cresult.Count

Dqueue.Count

Attempts:

3 left

💡 Hint

Common Mistakes

Decreasing inDegree[vertex] instead of inDegree[neighbor]

Using unrelated variables like result.Count or queue.Count as index

We decrease the in-degree of the neighbor because we have processed one of its incoming edges.

4fill in blank

hard

Fill both blanks to complete the function signature and return statement.

DSA C#

public static List<int> TopologicalSort([1] graph) {
    List<int> result = new List<int>();
    // ... algorithm code ...
    return [2];
}

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

AList<int>[]

Bint[]

Cresult

Dgraph

Attempts:

3 left

💡 Hint

Common Mistakes

Using int[] for graph parameter instead of List[]

Returning graph instead of result

The graph is represented as an array of lists of integers, and the function returns the result list.

5fill in blank

hard

Fill all three blanks to complete the main loop that performs Kahn's algorithm.

DSA C#

while (queue.Count > 0) {
    int [1] = queue.Dequeue();
    result.Add([2]);
    foreach (int neighbor in graph[[3]]) {
        inDegree[neighbor]--;
        if (inDegree[neighbor] == 0) {
            queue.Enqueue(neighbor);
        }
    }
}

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

Avertex

Dneighbor

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names in blanks

Using 'neighbor' instead of 'vertex' for indexing graph

The variable 'vertex' is dequeued, added to result, and used to access neighbors.

Practice

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

easy

A. To calculate the minimum spanning tree

B. To detect cycles in an undirected graph

C. To find the shortest path between two nodes

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

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 u -> v, u comes before v in the ordering.

2. Step 2: Compare with other graph algorithms

   Other options describe different graph problems: cycle detection, shortest path, and minimum spanning tree, which are not the purpose of Kahn's Algorithm.

3. Final Answer:

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

4. Quick Check:

   Topological sort = Kahn's Algorithm purpose [OK]

Hint: Kahn's Algorithm always finds order in DAGs [OK]

Common Mistakes:

• Confusing topological sort with cycle detection
• Thinking it finds shortest paths
• Mixing with minimum spanning tree algorithms

2. Which C# data structure is best suited to store nodes with zero incoming edges during Kahn's Algorithm?

easy

A. Queue

B. Stack

C. Dictionary

D. HashSet

Solution

1. Step 1: Identify the role of zero in-degree nodes

   Kahn's Algorithm processes nodes with zero incoming edges in the order they are discovered, which requires a First-In-First-Out (FIFO) structure.

2. Step 2: Match data structure to FIFO behavior

   A Queue provides FIFO behavior, making it ideal to store and process zero in-degree nodes in the correct order.

3. Final Answer:

   Queue -> Option A

4. Quick Check:

   Zero in-degree nodes use FIFO queue [OK]

Hint: Use queue for BFS order in Kahn's Algorithm [OK]

Common Mistakes:

• Using stack which is LIFO, not suitable here
• Choosing dictionary which stores key-value pairs
• Using hashset which has no order

3. What is the output of the following C# code snippet implementing Kahn's Algorithm on this graph?

var graph = new Dictionary<int, List<int>> {
  {1, new List<int> {2, 3}},
  {2, new List<int> {4}},
  {3, new List<int> {4}},
  {4, new List<int> ()}
};
var result = TopologicalSort(graph);
Console.WriteLine(string.Join(", ", result));

List<int> TopologicalSort(Dictionary<int, List<int>> graph) {
  var inDegree = new Dictionary<int, int>();
  foreach (var node in graph.Keys) inDegree[node] = 0;
  foreach (var edges in graph.Values)
    foreach (var v in edges) inDegree[v]++;
  var queue = new Queue<int>(inDegree.Where(kv => kv.Value == 0).Select(kv => kv.Key));
  var topoOrder = new List<int>();
  while (queue.Count > 0) {
    var u = queue.Dequeue();
    topoOrder.Add(u);
    foreach (var v in graph[u]) {
      inDegree[v]--;
      if (inDegree[v] == 0) queue.Enqueue(v);
    }
  }
  return topoOrder;
}

medium

A. [4, 2, 3, 1]

B. [1, 2, 3, 4]

C. [1, 3, 2, 4]

D. [2, 3, 1, 4]

Solution

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

   Node 1: 0, Node 2: 1 (from 1), Node 3: 1 (from 1), Node 4: 2 (from 2 and 3).

2. Step 2: Process nodes in queue order

   Start with node 1 (in-degree 0). Remove it, reduce in-degree of 2 and 3 to 0, enqueue both. Then dequeue 2, reduce in-degree of 4 to 1. Dequeue 3, reduce in-degree of 4 to 0, enqueue 4. Finally dequeue 4.

3. Final Answer:

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

4. Quick Check:

   Topological order = [1, 2, 3, 4] [OK]

Hint: Track in-degree and queue order carefully [OK]

Common Mistakes:

• Ignoring in-degree updates after dequeue
• Mixing order of nodes with same in-degree
• Starting with wrong initial nodes

4. Identify the bug in this Kahn's Algorithm C# code snippet:

var inDegree = new Dictionary<int, int>();
foreach (var node in graph.Keys) inDegree[node] = 0;
foreach (var edges in graph.Values)
  foreach (var v in edges) inDegree[v] = 0; // Bug here
var queue = new Queue<int>(inDegree.Where(kv => kv.Value == 0).Select(kv => kv.Key));

medium

A. Queue should be a stack for correct order

B. The first loop should initialize inDegree with -1

C. The second loop resets in-degree to zero instead of incrementing

D. The graph.Keys should be iterated twice

Solution

1. Step 1: Analyze in-degree calculation

   The second loop incorrectly sets inDegree[v] = 0 for each adjacent node, overwriting the count instead of incrementing it.

2. Step 2: Correct in-degree update

   It should increment inDegree[v] by 1 for each incoming edge to count properly, i.e., inDegree[v]++.

3. Final Answer:

   The second loop resets in-degree to zero instead of incrementing -> Option C

4. Quick Check:

   In-degree must be incremented, not reset [OK]

Hint: Increment in-degree counts, don't reset them [OK]

Common Mistakes:

• Setting in-degree to zero inside the counting loop
• Using stack instead of queue
• Misinitializing in-degree dictionary

5. Given a 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 Kahn's Algorithm?

hard

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

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

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

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

Solution

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

   Nodes: 0(in-degree 2 from 4,5), 1(in-degree 2 from 3,4), 2(in-degree 1 from 5), 3(in-degree 1 from 2), 4(in-degree 0), 5(in-degree 0).

2. Step 2: Process nodes with zero in-degree first

   Start with 5 and 4. Removing 5 reduces in-degree of 2 to 0 and 0 to 1; removing 4 reduces in-degree of 0 to 0 and 1 to 1. Then process 2 and 0 (in some order), followed by 3, then 1.

3. Final Answer:

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

4. Quick Check:

   Valid topological order respects edges [OK]

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

Common Mistakes:

• Placing nodes before their dependencies
• Ignoring multiple valid orders
• Starting with nodes that have incoming edges