Connected Components Using BFS in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the visited map for BFS.

DSA Go

visited := make(map[int]bool)
for _, node := range graph {
    visited[[1]] = false
}

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

Agraph

B0

Cnode

Dlen(graph)

Attempts:

3 left

💡 Hint

Common Mistakes

Using a fixed number like 0 or len(graph) as the key instead of the node variable.

We mark each node in the graph as not visited initially by using the node itself as the key.

2fill in blank

medium

Complete the code to enqueue the starting node in BFS.

DSA Go

queue := []int{}
queue = append(queue, [1])
visited[start] = true

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

Astart

Bgraph[0]

C0

Dlen(graph)

Attempts:

3 left

💡 Hint

Common Mistakes

Appending graph[0] or 0 instead of the start node.

We start BFS from the 'start' node, so we enqueue it first.

3fill in blank

hard

Fix the error in the BFS loop condition to continue while queue is not empty.

DSA Go

for len(queue) [1] 0 {
    current := queue[0]
    queue = queue[1:]
    // process current
}

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

A==

B!=

C<

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' or '==' which can cause infinite loops or no iteration.

We continue the loop while the queue length is greater than zero.

4fill in blank

hard

Fill both blanks to check and enqueue unvisited neighbors in BFS.

DSA Go

for _, neighbor := range graph[current] {
    if !visited[[1]] {
        queue = append(queue, [2])
        visited[neighbor] = true
    }
}

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

Aneighbor

Bcurrent

Cgraph

Dstart

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'current' or 'graph' instead of 'neighbor' in the condition or append.

We check if the neighbor is not visited and then enqueue the neighbor.

5fill in blank

hard

Fill all three blanks to count connected components using BFS.

DSA Go

count := 0
visited := make(map[int]bool)
for node := range graph {
    if !visited[node] {
        count[1]1
        queue := []int{node}
        visited[node] = true
        for len(queue) [2] 0 {
            current := queue[0]
            queue = queue[1:]
            for _, neighbor := range graph[current] {
                if !visited[neighbor] {
                    queue = append(queue, neighbor)
                    visited[neighbor] = true
                }
            }
        }
    }
}
return count[3]

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

A+=

B>

C!=

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using '=' instead of '+=' for count increment.

Using wrong loop condition operators.

Returning count with wrong comparison.

We increment count by 1 for each new component, loop while queue length > 0, and return count != 0 to indicate presence of components.

Practice

1. What does the BFS algorithm help find in an undirected graph when used for connected components?

easy

A. The total number of edges in the graph

B. The shortest path between two nodes only

C. The maximum degree of any node in the graph

D. All nodes reachable from a starting node forming one connected component

Solution

1. Step 1: Understand BFS role in connected components

   BFS explores all nodes reachable from a given start node, grouping them as one connected component.

2. Step 2: Differentiate BFS from other graph properties

   BFS does not directly find shortest paths between arbitrary nodes, max degree, or edge count in this context.

3. Final Answer:

   All nodes reachable from a starting node forming one connected component -> Option D

4. Quick Check:

   BFS finds connected components [OK]

Hint: BFS visits all nodes in one connected group [OK]

Common Mistakes:

• Confusing BFS with shortest path only
• Thinking BFS counts edges or degrees
• Mixing connected components with graph size

2. Which of the following Go code snippets correctly initializes a queue for BFS traversal?

easy

A. queue := []int{} // empty slice for BFS queue

B. queue := make(map[int]bool) // map used as queue

C. queue := 0 // integer used as queue

D. queue := "queue" // string used as queue"

Solution

1. Step 1: Identify correct queue data structure for BFS

   BFS requires a queue to hold nodes; a slice of ints is a common and correct choice in Go.

2. Step 2: Eliminate incorrect queue initializations

   Maps, integers, or strings cannot function as queues for BFS traversal.

3. Final Answer:

   queue := []int{} // empty slice for BFS queue -> Option A

4. Quick Check:

   Queue for BFS = slice of ints [OK]

Hint: Use slice of ints as queue in Go BFS [OK]

Common Mistakes:

• Using map instead of slice for queue
• Using integer or string as queue
• Not initializing queue before BFS

3. Given the following graph adjacency list and BFS code, what is the output number of connected components?

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

visited := make(map[int]bool)
count := 0
for node := range graph {
  if !visited[node] {
    queue := []int{node}
    visited[node] = true
    for len(queue) > 0 {
      current := queue[0]
      queue = queue[1:]
      for _, neighbor := range graph[current] {
        if !visited[neighbor] {
          visited[neighbor] = true
          queue = append(queue, neighbor)
        }
      }
    }
    count++
  }
}
fmt.Println(count)

medium

A. 3

B. 2

C. 1

D. 4

Solution

1. Step 1: Identify connected components in the graph

   Nodes 0,1,2 form one component; nodes 3,4 form second; node 5 alone forms third.

2. Step 2: BFS visits each component once, incrementing count

   Loop visits nodes 0,3,5 as unvisited starts, counting 3 components total.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   3 connected components = 3 [OK]

Hint: Count BFS starts on unvisited nodes [OK]

Common Mistakes:

• Counting edges instead of components
• Missing isolated nodes as components
• Not marking visited nodes properly

4. The following BFS code for counting connected components has a bug. What is the error?

func countComponents(graph map[int][]int) int {
  visited := make(map[int]bool)
  count := 0
  for node := range graph {
    if visited[node] {
      queue := []int{node}
      visited[node] = true
      for len(queue) > 0 {
        current := queue[0]
        queue = queue[1:]
        for _, neighbor := range graph[current] {
          if !visited[neighbor] {
            visited[neighbor] = true
            queue = append(queue, neighbor)
          }
        }
      }
      count++
    }
  }
  return count
}

medium

A. The visited map is not initialized

B. The queue initialization is incorrect

C. The condition should be if !visited[node], not if visited[node]

D. The count variable is not incremented

Solution

1. Step 1: Analyze the if condition for BFS start

   The code starts BFS only if visited[node] is true, which is wrong; it should start if node is not visited.

2. Step 2: Understand impact on BFS traversal

   Because of wrong condition, BFS never starts, so count remains zero incorrectly.

3. Final Answer:

   The condition should be if !visited[node], not if visited[node] -> Option C

4. Quick Check:

   Start BFS on unvisited nodes [OK]

Hint: Start BFS only if node is unvisited [OK]

Common Mistakes:

• Using visited[node] instead of !visited[node]
• Not initializing visited map
• Forgetting to increment count

5. You have a graph with nodes 0 to 6 and edges: (0-1), (1-2), (3-4), (5-6). Using BFS to find connected components, what is the count if node 7 is isolated and missing from the adjacency list? Choose the correct approach to count all components including isolated nodes.

hard

A. Count only nodes connected by edges

B. Include node 7 in the graph map with empty adjacency list before BFS

C. Ignore node 7 since it is not in adjacency list

D. Add node 7 as connected to node 0

Solution

1. Step 1: Recognize isolated nodes must be in graph map

   To count isolated nodes as components, they must appear in the graph with empty adjacency lists.

2. Step 2: Include node 7 with empty neighbors before BFS

   Adding node 7 ensures BFS visits it as a separate component.

3. Final Answer:

   Include node 7 in the graph map with empty adjacency list before BFS -> Option B

4. Quick Check:

   Isolated nodes need empty adjacency list [OK]

Hint: Add isolated nodes with empty lists to graph before BFS [OK]

Common Mistakes:

• Ignoring isolated nodes not in adjacency list
• Assuming isolated nodes are counted automatically
• Connecting isolated nodes incorrectly