Connected Components Using BFS in DSA Go - Build from Scratch

Connected Components Using BFS

📖 Scenario: Imagine you have a map of cities connected by roads. You want to find groups of cities where each city is reachable from any other city in the same group by traveling along these roads.

🎯 Goal: Build a program that finds all connected groups of cities using Breadth-First Search (BFS).

📋 What You'll Learn

Create a graph using a map where keys are city names (strings) and values are slices of connected city names.

Create a map to keep track of visited cities.

Implement BFS to find all connected components in the graph.

Print each connected component as a slice of city names.

💡 Why This Matters

🌍 Real World

Finding connected groups in networks like social media friends, computer networks, or city maps helps understand clusters and connectivity.

💼 Career

Graph traversal and connected components are common in software engineering roles involving data analysis, network design, and algorithm development.

1

Create the graph of cities

Create a variable called graph as a map[string][]string with these exact entries: "A": {"B", "C"}, "B": {"A", "D"}, "C": {"A"}, "D": {"B"}, "E": {"F"}, "F": {"E"}.

DSA Go

# Your code here

Hint

Use a map with string keys and slice of strings as values to represent the graph.

2

Create the visited map

Add a variable called visited as a map[string]bool and initialize it as an empty map.

DSA Go

package main

func main() {
    graph := map[string][]string{
        "A": {"B", "C"},
        "B": {"A", "D"},
        "C": {"A"},
        "D": {"B"},
        "E": {"F"},
        "F": {"E"},
    }
    // Create visited map here
    
    // Your code here
}

Hint

Use make(map[string]bool) to create an empty map for visited cities.

3

Implement BFS to find connected components

Write a function called bfs that takes start string, graph map[string][]string, and visited map[string]bool and returns a slice of strings representing the connected component. Use a queue to explore neighbors and mark cities visited.

DSA Go

package main

func bfs(start string, graph map[string][]string, visited map[string]bool) []string {
    // Your code here
    return nil
}

func main() {
    graph := map[string][]string{
        "A": {"B", "C"},
        "B": {"A", "D"},
        "C": {"A"},
        "D": {"B"},
        "E": {"F"},
        "F": {"E"},
    }
    visited := make(map[string]bool)
}

Hint

Use a slice as a queue. Mark cities visited when added to the queue. Collect cities in the component slice.

4

Find and print all connected components

In main, create a slice of slices of strings called components. Use a for loop with variable city over graph keys. If visited[city] is false, call bfs(city, graph, visited) and append the result to components. Finally, print components.

DSA Go

Hint

Loop over all cities. For unvisited cities, run BFS and collect connected components. Print the list 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