Number of Islands BFS and DFS in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of BFS-based Number of Islands

What is the output of the following Rust code that counts islands using BFS?

DSA Rust

fn num_islands_bfs(grid: Vec<Vec<char>>) -> i32 {
    use std::collections::VecDeque;
    let rows = grid.len();
    if rows == 0 { return 0; }
    let cols = grid[0].len();
    let mut grid = grid;
    let mut count = 0;
    let directions = [(1,0), (-1,0), (0,1), (0,-1)];

    for r in 0..rows {
        for c in 0..cols {
            if grid[r][c] == '1' {
                count += 1;
                let mut queue = VecDeque::new();
                queue.push_back((r, c));
                grid[r][c] = '0';

                while let Some((x, y)) = queue.pop_front() {
                    for (dx, dy) in directions.iter() {
                        let nx = x as isize + dx;
                        let ny = y as isize + dy;
                        if nx >= 0 && nx < rows as isize && ny >= 0 && ny < cols as isize {
                            let (nx, ny) = (nx as usize, ny as usize);
                            if grid[nx][ny] == '1' {
                                queue.push_back((nx, ny));
                                grid[nx][ny] = '0';
                            }
                        }
                    }
                }
            }
        }
    }
    count
}

fn main() {
    let grid = 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']
    ];
    println!("{}", num_islands_bfs(grid));
}

A 2

B 1

C 4

D 3

💡 Hint

Count how many separate groups of '1's are connected horizontally or vertically.

The grid has three separate islands: one at top-left, one in the middle, and one at bottom-right.

❓ Predict Output

intermediate

Output of DFS-based Number of Islands

What is the output of this Rust code that counts islands using DFS?

DSA Rust

fn num_islands_dfs(grid: Vec<Vec<char>>) -> i32 {
    fn dfs(grid: &mut Vec<Vec<char>>, r: usize, c: usize) {
        if r >= grid.len() || c >= grid[0].len() || grid[r][c] == '0' {
            return;
        }
        grid[r][c] = '0';
        if r > 0 { dfs(grid, r - 1, c); }
        if c > 0 { dfs(grid, r, c - 1); }
        if r + 1 < grid.len() { dfs(grid, r + 1, c); }
        if c + 1 < grid[0].len() { dfs(grid, r, c + 1); }
    }

    let mut grid = grid;
    let mut count = 0;
    for r in 0..grid.len() {
        for c in 0..grid[0].len() {
            if grid[r][c] == '1' {
                count += 1;
                dfs(&mut grid, r, c);
            }
        }
    }
    count
}

fn main() {
    let grid = 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']
    ];
    println!("{}", num_islands_dfs(grid));
}

A 3

B 2

C 1

D 4

💡 Hint

DFS explores all connected land cells recursively.

The DFS marks all connected '1's as '0' and counts 3 islands in the grid.

🧠 Conceptual

advanced

Why BFS or DFS is suitable for Number of Islands?

Why do BFS and DFS work well for counting islands in a grid?

A Because they sort the grid cells to find islands faster.

B Because they explore all connected land cells systematically, marking visited cells to avoid recounting.

C Because they use hashing to store island coordinates efficiently.

D Because they convert the grid into a tree structure before counting.

💡 Hint

Think about how connected components are found in graphs.

BFS and DFS traverse all connected land cells, marking them visited to count each island once.

🔧 Debug

advanced

Identify the bug in this DFS code snippet

What error will this Rust DFS code cause when counting islands?

DSA Rust

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

A Runtime error due to accessing grid out of bounds when r or c is 0.

B Stack overflow due to infinite recursion when r or c is 0.

C No error; code runs correctly.

D Compilation error because of missing return type.

💡 Hint

Check how negative indices are handled in Rust usize type.

Subtracting 1 from 0 in usize causes underflow, leading to out-of-bounds access at runtime.

🚀 Application

expert

Optimizing Number of Islands for Large Grids

Which approach best optimizes counting islands in a very large grid with mostly water cells?

A Use BFS or DFS but skip cells that are '0' to reduce unnecessary traversal.

B Sort all cells by row and column and count islands by scanning sorted cells.

C Use a Union-Find (Disjoint Set) data structure to merge connected lands efficiently.

D Convert the grid to a graph and run Dijkstra's algorithm to find islands.

💡 Hint

Think about data structures that efficiently merge connected components.

Union-Find efficiently merges connected land cells and counts distinct sets, optimizing large grids.

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