Number of Islands BFS and DFS in DSA Rust - Build from Scratch

Number of Islands BFS and DFS

📖 Scenario: Imagine you have a map of a small island region represented as a grid. Each cell in the grid can be land ('1') or water ('0'). You want to find out how many separate islands are there. An island is a group of connected land cells horizontally or vertically.

🎯 Goal: You will build a Rust program that counts the number of islands in the grid using two common methods: Breadth-First Search (BFS) and Depth-First Search (DFS). This helps understand how to explore connected parts of a grid.

📋 What You'll Learn

Create a 2D vector called grid with exact values representing land and water

Create a variable called rows to store the number of rows in grid

Implement a function num_islands_dfs that counts islands using DFS

Implement a function num_islands_bfs that counts islands using BFS

Print the number of islands found by both methods

💡 Why This Matters

🌍 Real World

Counting islands in a grid is similar to detecting connected regions in maps, image processing, or network clusters.

💼 Career

Understanding BFS and DFS is essential for software engineers working on graph problems, pathfinding, and spatial data analysis.

1

Create the island map grid

Create a 2D vector called grid with these exact rows: vec!["1", "1", "0", "0", "0"], vec!["1", "1", "0", "0", "0"], vec!["0", "0", "1", "0", "0"], vec!["0", "0", "0", "1", "1"]. Use Vec> type.

DSA Rust

# Create the 2D vector grid with the exact values
# Your code here

Hint

Use vec![vec!["1", "1", "0", "0", "0"]] for each row exactly as shown.

2

Add rows count variable

Create a variable called rows and set it to the number of rows in grid using grid.len().

DSA Rust

let grid: Vec> = vec![
    vec!["1", "1", "0", "0", "0"],
    vec!["1", "1", "0", "0", "0"],
    vec!["0", "0", "1", "0", "0"],
    vec!["0", "0", "0", "1", "1"],
];
# Create a variable rows and set it to grid.len()
# Your code here

Hint

Use let rows = grid.len(); to get the number of rows.

3

Implement DFS function to count islands

Write a function called num_islands_dfs that takes a mutable reference to a 2D vector grid of Vec> and returns an i32. Use DFS to mark visited land cells by changing "1" to "0". Count and return the number of islands.

DSA Rust

let grid: Vec> = vec![
    vec!["1", "1", "0", "0", "0"],
    vec!["1", "1", "0", "0", "0"],
    vec!["0", "0", "1", "0", "0"],
    vec!["0", "0", "0", "1", "1"],
];

let rows = grid.len();

// Write function num_islands_dfs(grid: &mut Vec>) -> i32
// Your code here

Hint

Use a helper function dfs to mark connected land cells as visited by setting them to "0".

4

Implement BFS function and print results

Write a function called num_islands_bfs that takes a mutable reference to a 2D vector grid of Vec> and returns an i32. Use BFS to count islands similarly to DFS. Then print the number of islands found by num_islands_dfs and num_islands_bfs on the original grid.

DSA Rust

let mut grid: Vec> = vec![
    vec!["1", "1", "0", "0", "0"],
    vec!["1", "1", "0", "0", "0"],
    vec!["0", "0", "1", "0", "0"],
    vec!["0", "0", "0", "1", "1"],
];

let rows = grid.len();

// Implement num_islands_bfs function
// Call num_islands_dfs and num_islands_bfs on copies of grid
// Print the results
# Your code here

Hint

Use a queue with VecDeque for BFS. Remember to mark visited cells as "0".

Practice

1. What does the "Number of Islands" problem ask you to find in a grid of '1's and '0's?

easy

A. Find the largest island size in the grid

B. Count how many '0's are in the grid

C. Count how many groups of connected '1's (islands) are in the grid

D. Calculate the perimeter of all islands combined

Solution

1. Step 1: Understand the grid content

   The grid contains '1's representing land and '0's representing water.

2. Step 2: Define the problem goal

   The problem asks to count how many separate groups of connected '1's exist, called islands.

3. Final Answer:

   Count how many groups of connected '1's (islands) are in the grid -> Option C

4. Quick Check:

   Number of islands = count of connected '1' groups [OK]

Hint: Islands = groups of connected '1's, count them [OK]

Common Mistakes:

• Confusing island count with largest island size
• Counting '0's instead of '1's
• Calculating perimeter instead of count

2. Which Rust code snippet correctly initializes a 2D vector grid of chars for the Number of Islands problem?

easy

A. let grid: Vec<char> = vec!['1', '0', '0', '1'];

B. let grid: Vec = vec![vec!['1', '0'], vec!['0', '1']];

C. let grid: Vec = vec![vec![1, 0], vec![0, 1]];

D. let grid = [[1, 0], [0, 1]];

Solution

1. Step 1: Identify correct data type for grid

   The grid should be a 2D vector of chars because the problem uses '1' and '0' as characters.

2. Step 2: Check syntax for 2D vector initialization

   let grid: Vec = vec![vec!['1', '0'], vec!['0', '1']]; uses Vec with vec! macro and char literals '1' and '0', which is correct Rust syntax.

3. Final Answer:

   let grid: Vec = vec![vec!['1', '0'], vec!['0', '1']]; -> Option B

4. Quick Check:

   2D vector of chars with vec! and '1'/'0' chars [OK]

Hint: Use Vec with vec![vec!['1', '0'], ...] [OK]

Common Mistakes:

• Using integer types instead of char
• Using arrays without specifying type
• Using 1D vector instead of 2D

3. Given the following Rust code using DFS to count islands, what is the output?

fn main() {
    let mut grid = vec![
        vec!['1', '1', '0', '0'],
        vec!['1', '0', '0', '1'],
        vec!['0', '0', '1', '1'],
        vec!['0', '0', '0', '0'],
    ];
    println!("{}", num_islands(&mut grid));
}

fn num_islands(grid: &mut Vec) -> i32 {
    let mut count = 0;
    for i in 0..grid.len() {
        for j in 0..grid[0].len() {
            if grid[i][j] == '1' {
                dfs(grid, i, j);
                count += 1;
            }
        }
    }
    count
}

fn dfs(grid: &mut Vec, i: usize, j: usize) {
    if i >= grid.len() || j >= grid[0].len() || grid[i][j] == '0' {
        return;
    }
    grid[i][j] = '0';
    if i > 0 { dfs(grid, i - 1, j); }
    dfs(grid, i + 1, j);
    if j > 0 { dfs(grid, i, j - 1); }
    dfs(grid, i, j + 1);
}

medium

A. 5

B. 4

C. 2

D. 3

Solution

1. Step 1: Identify islands in the grid

   The grid has these islands: - Top-left corner: (0,0),(0,1),(1,0) - Single '1' at (1,3) - Connected '1's at (2,2),(2,3)

2. Step 2: Count islands after DFS marks visited

   DFS marks connected '1's as '0' to avoid recounting. Total islands found = 3.

3. Final Answer:

   3 -> Option D

4. Quick Check:

   Count connected groups = 3 [OK]

Hint: Count connected '1' groups, DFS marks visited [OK]

Common Mistakes:

• Counting diagonal connections as islands
• Not marking visited cells
• Off-by-one errors in loops

4. The following Rust DFS code for Number of Islands has a bug. What is the bug?

fn dfs(grid: &mut Vec, i: usize, j: usize) {
    if i > grid.len() || j > grid[0].len() || grid[i][j] == '0' {
        return;
    }
    grid[i][j] = '0';
    if i > 0 { dfs(grid, i - 1, j); }
    dfs(grid, i + 1, j);
    if j > 0 { dfs(grid, i, j - 1); }
    dfs(grid, i, j + 1);
}

medium

A. The boundary check uses '>' instead of '>=' causing out-of-bounds panic

B. The grid is not marked visited correctly

C. The DFS does not check for diagonal neighbors

D. The function does not return the island count

Solution

1. Step 1: Analyze boundary condition in DFS

   The code checks if i > grid.len() or j > grid[0].len(), but valid indices go up to len()-1, so i == len() is out-of-bounds.

2. Step 2: Correct boundary check to prevent panic

   Use i >= grid.len() and j >= grid[0].len() to avoid accessing invalid indices and crashing.

3. Final Answer:

   The boundary check uses '>' instead of '>=' causing out-of-bounds panic -> Option A

4. Quick Check:

   Use >= for boundary checks to avoid panic [OK]

Hint: Use >= for boundary checks to avoid index errors [OK]

Common Mistakes:

• Using > instead of >= in boundary checks
• Forgetting to mark visited cells
• Ignoring out-of-bounds errors

5. You want to modify the Number of Islands BFS solution to also return the size of the largest island. Which change is correct?

hard

A. Add a counter inside BFS to count connected '1's and track max size

B. Count '1's in the grid before BFS and return that count

C. Use DFS instead of BFS without any modification

D. Return the total number of '0's as the largest island size

Solution

1. Step 1: Understand BFS traversal for islands

   BFS visits all connected '1's in an island. Counting visited nodes during BFS gives island size.

2. Step 2: Track and update largest island size

   Maintain a counter inside BFS for current island size, update max size after BFS completes for each island.

3. Final Answer:

   Add a counter inside BFS to count connected '1's and track max size -> Option A

4. Quick Check:

   Count nodes during BFS to find largest island size [OK]

Hint: Count nodes during BFS, update max size [OK]

Common Mistakes:

• Counting '1's before BFS (not island size)
• Using DFS without counting size
• Returning count of '0's instead of island size