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 with zeros.

DSA C++

vector<int> indegree(V, [1]);

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

A0

B1

C-1

DV

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing in-degree with 1 or negative values causes wrong counts.

Using V as initial value leads to incorrect in-degree.

The in-degree array should start with zero for all vertices because initially no edges are counted.

2fill in blank

medium

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

DSA C++

for (int i = 0; i < V; i++) {
    if (indegree[i] [1] 0) {
        q.push(i);
    }
}

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

A!=

B>

C<

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' or '>' causes wrong nodes to be pushed.

Using '<' misses nodes with zero in-degree.

We push nodes with zero in-degree because they have no dependencies and can be processed first.

3fill in blank

hard

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

DSA C++

while (!q.empty()) {
    int node = q.front();
    q.pop();
    for (auto it : adj[node]) {
        indegree[it] [1] 1;
        if (indegree[it] == 0) {
            q.push(it);
        }
    }
}

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

A+=

B-=

C=

D*=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+=' increases in-degree incorrectly.

Using '=' assigns wrong values.

Using '*=' multiplies in-degree incorrectly.

We decrease the in-degree by 1 for each adjacent node because one dependency is processed.

4fill in blank

hard

Fill both blanks to correctly add nodes to the result and check for cycle.

DSA C++

vector<int> topo;
int count = 0;
while (!q.empty()) {
    int node = q.front();
    q.pop();
    topo.[1](node);
    count[2] 1;
    for (auto it : adj[node]) {
        indegree[it] -= 1;
        if (indegree[it] == 0) {
            q.push(it);
        }
    }
}
if (count != V) {
    cout << "Cycle detected, topological sort not possible";
}

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

Apush_back

Bpop_back

C+=

D-=

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop_back removes elements instead of adding.

Using '-=' decreases count incorrectly.

We add the node to the topo vector using push_back and increase count by 1 to track processed nodes.

5fill in blank

hard

Fill all three blanks to print the topological order correctly.

DSA C++

for (int i = 0; i [1] topo.size(); i++) {
    cout << topo[i];
    if (i [2] topo.size() - 1) {
        cout << [3];
    }
}

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

A<

B==

C" -> "

D"\n"

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' in loop condition causes only one iteration.

Printing arrow after last element causes formatting issues.

We loop from 0 to less than topo.size(), print ' -> ' between nodes except after the last one.

Practice

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

easy

A. To find the shortest path between two nodes

B. To calculate the minimum spanning tree

C. To detect cycles in an undirected graph

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 algorithms: shortest path (Dijkstra's or BFS), cycle detection in undirected graphs (DFS), and minimum spanning tree (Kruskal's or Prim's) are unrelated to 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 topological order in DAGs [OK]

Common Mistakes:

• Confusing topological sort with shortest path
• Thinking it works on undirected graphs
• Assuming it detects cycles directly

2. Which of the following C++ STL containers is best suited to implement the queue used in Kahn's Algorithm?

easy

A. std::queue

B. std::set

C. std::vector

D. std::stack

Solution

1. Step 1: Identify the data structure needed

   Kahn's Algorithm uses a queue to process nodes with zero incoming edges in FIFO order.

2. Step 2: Match with C++ STL containers

   std::queue provides FIFO behavior, suitable for this purpose. std::stack is LIFO, std::vector is dynamic array without FIFO, std::set is ordered but not FIFO.

3. Final Answer:

   std::queue -> Option A

4. Quick Check:

   Queue = std::queue [OK]

Hint: Use std::queue for FIFO processing in Kahn's Algorithm [OK]

Common Mistakes:

• Using std::stack instead of std::queue
• Using std::vector without queue operations
• Using std::set which is ordered but not FIFO

3. What is the output of the following code snippet implementing Kahn's Algorithm on the graph with edges: 5->0, 5->2, 4->0, 4->1, 2->3, 3->1?

std::vector graph = {{}, {}, {}, {}, {}, {}};
// Edges added as graph[5].push_back(0), etc.
// After running Kahn's Algorithm, which topological order is printed?
// Options are sequences of node numbers.

medium

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

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

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

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

Solution

1. Step 1: Build indegree and initialize queue

   Nodes 4 and 5 have zero indegree, so queue starts with [4,5].

2. Step 2: Process nodes in queue order

   Process 4: remove edges 4->0, 4->1; indegree of 0 and 1 decrease. Process 5: remove edges 5->0, 5->2; indegree of 0 and 2 decrease. When indegree of 0 and 2 become zero, add to queue. Continue processing 0, 2, 3, 1 in order.

3. Final Answer:

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

4. Quick Check:

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

Hint: Start with nodes having zero indegree in queue [OK]

Common Mistakes:

• Starting queue with wrong nodes
• Not updating indegree correctly
• Mixing order of nodes with zero indegree

4. What is missing from this Kahn's Algorithm implementation:

std::vector<int> indegree(V, 0);
for (int u = 0; u < V; u++) {
  for (int v : graph[u]) {
    indegree[v]++;
  }
}
std::queue<int> q;
for (int i = 0; i < V; i++) {
  if (indegree[i] == 0) q.push(i);
}
while (!q.empty()) {
  int u = q.front(); q.pop();
  for (int v : graph[u]) {
    indegree[v]--;
    if (indegree[v] == 0) q.push(v);
  }
  // Missing code here
}

medium

A. Not decrementing indegree[v] inside the loop

B. Not printing or storing the topological order nodes

C. Not checking if the graph has cycles before running

D. Not pushing nodes with zero indegree into the queue initially

Solution

1. Step 1: Analyze the loop behavior

   The code correctly calculates indegree and pushes zero indegree nodes into the queue. It decrements indegree and pushes new zero indegree nodes inside the loop.

2. Step 2: Identify missing action

   The missing code is to store the popped node u into a topological order vector, e.g., topo.push_back(u); after q.pop();. Without it, the algorithm processes correctly but does not output the order.

3. Final Answer:

   Not printing or storing the topological order nodes -> Option B

4. Quick Check:

   Missing topo.push_back(u) [OK]

Hint: Always record nodes when popping from queue [OK]

Common Mistakes:

• Forgetting to store or print topological order
• Incorrect indegree decrement logic
• Not initializing queue with zero indegree nodes

5. Given a Directed Acyclic Graph (DAG) with 6 nodes and edges: 0->1, 0->2, 1->3, 2->3, 3->4, 4->5, how can Kahn's Algorithm be modified to detect if the graph contains a cycle?

hard

A. Count processed nodes; if count < total nodes, a cycle exists

B. Check if queue becomes empty

C. Use a visited array to mark nodes and detect back edges

D. Run DFS instead of BFS to find cycles

Solution

1. Step 1: Understand Kahn's Algorithm processing

   Kahn's Algorithm processes nodes with zero indegree and removes edges. If a cycle exists, some nodes never reach zero indegree and remain unprocessed.

2. Step 2: Detect cycle by counting processed nodes

   If the number of processed nodes is less than total nodes, it means some nodes are stuck due to cycles. This is a standard cycle detection method using Kahn's Algorithm.

3. Final Answer:

   Count processed nodes; if count < total nodes, a cycle exists -> Option A

4. Quick Check:

   Processed nodes count < total nodes = cycle [OK]

Hint: Compare processed nodes count with total nodes [OK]

Common Mistakes:

• Assuming Kahn's Algorithm alone detects cycles without counting
• Confusing BFS with DFS cycle detection methods
• Not tracking processed nodes count