Number of Islands BFS and DFS in DSA Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main goal of the Number of Islands problem?

To count how many separate groups of connected '1's (land) exist in a 2D grid of '1's and '0's (land and water).

intermediate

How does Depth-First Search (DFS) help solve the Number of Islands problem?

DFS explores all connected land cells from a starting point by going deep into neighbors recursively, marking visited cells to avoid counting the same island multiple times.

intermediate

How does Breadth-First Search (BFS) differ from DFS in solving Number of Islands?

BFS explores neighbors level by level using a queue, visiting all adjacent land cells before moving deeper, but both BFS and DFS mark visited cells to count islands correctly.

intermediate

In Rust, what data structure is commonly used to implement BFS for Number of Islands?

A VecDeque is used as a queue to hold cells to visit next during BFS traversal.

beginner

Why do we mark visited cells in Number of Islands algorithms?

To avoid counting the same land cell multiple times and to prevent infinite loops during traversal.

What does a '1' represent in the Number of Islands grid?

A Obstacle

B Water

C Land

D Visited cell

In the grid, '1' represents land, and '0' represents water.

Which traversal method uses a stack or recursion to explore deep paths first?

A Breadth-First Search (BFS)

B Depth-First Search (DFS)

C Binary Search

D Linear Search

DFS uses recursion or a stack to explore as deep as possible before backtracking.

In BFS for Number of Islands, which data structure is used to keep track of cells to visit next?

A Queue

B Stack

C HashMap

D Array

BFS uses a queue to explore neighbors level by level.

What is the purpose of marking cells as visited in Number of Islands algorithms?

A To sort the grid

B To count water cells

C To increase island count

D To avoid revisiting the same land cell

Marking visited cells prevents counting the same island multiple times.

Which of these is NOT a valid neighbor direction in Number of Islands problem?

A Diagonal

B Up

C Left

D Down

Only horizontal and vertical neighbors (up, down, left, right) are considered connected.

Explain how DFS can be used to count the number of islands in a grid.

Think about exploring deep into connected land cells before moving on.

Describe the differences and similarities between BFS and DFS when solving Number of Islands.

Focus on traversal order and data structures used.

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