Number of Islands BFS and DFS in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start BFS from the given cell.

DSA Javascript

function bfs(grid, row, col, visited) {
  const queue = [];
  queue.push([row, col]);
  visited[row][col] = [1];
  while (queue.length > 0) {
    const [r, c] = queue.shift();
    // BFS logic here
  }
}

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

Atrue

Bundefined

Cnull

Dfalse

Attempts:

3 left

💡 Hint

Common Mistakes

Marking visited as false instead of true

Not marking the starting cell as visited

We mark the starting cell as visited by setting visited[row][col] to true.

2fill in blank

medium

Complete the code to check if a cell is within grid bounds.

DSA Javascript

function isValid(grid, row, col) {
  return row >= 0 && row < grid.length && col >= 0 && col < [1];
}

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

Agrid[0].length

Bgrid.length

Cgrid.length - 1

Dgrid[0].length - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using grid.length for columns

Using grid[0].length - 1 which excludes last column

The number of columns is grid[0].length, so col must be less than this.

3fill in blank

hard

Fix the error in the DFS recursive call to explore neighbors.

DSA Javascript

function dfs(grid, row, col, visited) {
  if (!isValid(grid, row, col) || visited[row][col] || grid[row][col] === '0') {
    return;
  }
  visited[row][col] = true;
  dfs(grid, row + 1, col, visited);
  dfs(grid, row - 1, col, visited);
  dfs(grid, row, col + 1, visited);
  dfs(grid, row, col [1], visited);
}

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

A+ 1

B- 1

C+ 2

D- 2

Attempts:

3 left

💡 Hint

Common Mistakes

Using +1 instead of -1 for left neighbor

Using +2 or -2 which skips cells

The last DFS call should explore the left neighbor by decreasing the column index by 1.

4fill in blank

hard

Fill both blanks to correctly check neighbors in BFS.

DSA Javascript

const directions = [[1, 0], [-1, 0], [0, 1], [0, [1]]];
for (const [dr, dc] of directions) {
  const nr = r + dr;
  const nc = c + dc;
  if (isValid(grid, nr, nc) && !visited[nr][nc] && grid[nr][nc] === '1') {
    queue.push([nr, nc]);
    visited[nr][nc] = [2];
  }
}

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

A-1

Btrue

Cfalse

D+1

Attempts:

3 left

💡 Hint

Common Mistakes

Using +1 instead of -1 for left direction

Marking visited as false

The last direction is left, so column change is -1. Visited cells are marked true.

5fill in blank

hard

Fill both blanks to create a dictionary comprehension that counts islands using DFS.

DSA Javascript

let count = 0;
for (let i = 0; i < grid.length; i++) {
  for (let j = 0; j < grid[0].length; j++) {
    if (grid[i][j] === '1' && !visited[i][j]) {
      [1](grid, i, j, visited);
      count[2];
    }
  }
}
return count;;

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

Adfs

B++

C;

D--

Attempts:

3 left

💡 Hint

Common Mistakes

Using BFS instead of DFS here (both valid but question expects DFS)

Using -- instead of ++ to update count

Missing semicolon at return

We call dfs to explore the island, increment count by 1, and return count with a semicolon.

Practice

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

easy

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

B. Find the largest island size in the grid

C. Calculate the total number of '0's in the grid

D. Replace all '1's with '0's in the grid

Solution

1. Step 1: Understand the grid representation

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

2. Step 2: Identify what an island means

   An island is a group of connected '1's horizontally or vertically.

3. Final Answer:

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

4. Quick Check:

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

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

Common Mistakes:

• Confusing island count with largest island size
• Counting '0's instead of '1's
• Ignoring connectivity rules (only horizontal/vertical)

2. Which of the following is the correct way to start a DFS function in JavaScript for the Number of Islands problem?

easy

A. function dfs(grid, r, c) { if (r < 0 || c < 0) return; }

B. function dfs(grid, r, c) { if (r <= 0 || c <= 0 || r > grid.length || c > grid[0].length) return; }

C. function dfs(grid, r, c) { if (r > grid.length || c > grid[0].length) return; }

D. function dfs(grid, r, c) { if (r < 0 || c < 0 || r >= grid.length || c >= grid[0].length) return; }

Solution

1. Step 1: Check boundary conditions for DFS

   We must stop DFS if row or column is outside grid bounds.

2. Step 2: Write correct boundary check

   Row or column less than 0 or greater or equal to grid size means out of bounds.

3. Final Answer:

   function dfs(grid, r, c) { if (r < 0 || c < 0 || r >= grid.length || c >= grid[0].length) return; } -> Option D

4. Quick Check:

   Boundary check includes all invalid indices [OK]

Hint: Check all out-of-bound indices with < 0 or >= length [OK]

Common Mistakes:

• Using > instead of >= for boundary check
• Missing some boundary conditions
• Using <= 0 which excludes valid index 0

3. What will be the output of the following code snippet for the grid below?

const grid = [ ['1','1','0','0'], ['1','0','0','1'], ['0','0','1','1'], ['0','0','0','0'] ]; function numIslands(grid) { let count = 0; const dfs = (r, c) => { if (r < 0 || c < 0 || r >= grid.length || c >= grid[0].length || grid[r][c] === '0') return; grid[r][c] = '0'; dfs(r + 1, c); dfs(r - 1, c); dfs(r, c + 1); dfs(r, c - 1); }; for (let r = 0; r < grid.length; r++) { for (let c = 0; c < grid[0].length; c++) { if (grid[r][c] === '1') { dfs(r, c); count++; } } } return count; } console.log(numIslands(grid));

medium

A. 1

B. 3

C. 2

D. 4

Solution

1. Step 1: Identify islands in the grid

   Islands are groups of connected '1's. Here, islands are: top-left (3 cells: (0,0),(0,1),(1,0)), single cell at (1,3), and bottom cluster (2 cells: (2,2),(2,3)). Total islands = 3.

2. Step 2: Count islands using DFS

   DFS marks visited '1's as '0'. After visiting each island, count increments. Total islands counted = 3.

3. Final Answer:

   3 -> Option B

4. Quick Check:

   Count connected '1' groups = 3 [OK]

Hint: Count connected '1' groups by marking visited [OK]

Common Mistakes:

• Counting diagonal connections as islands
• Not marking visited cells, causing overcount
• Misreading grid layout

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

function bfs(grid, r, c) { const queue = [[r, c]]; while (queue.length > 0) { const [row, col] = queue.shift(); if (row < 0 || col < 0 || row >= grid.length || col >= grid[0].length || grid[row][col] === '0') continue; grid[row][col] = '0'; queue.push([row + 1, col]); queue.push([row - 1, col]); queue.push([row, col + 1]); queue.push([row, col - 1]); } }

medium

A. It does not check if a cell is already visited before pushing neighbors

B. It marks visited cells after adding neighbors to queue

C. It uses queue.shift() which is inefficient for large grids

D. It uses recursion instead of iteration

Solution

1. Step 1: Analyze neighbor addition in BFS

   The code adds neighbors to the queue without checking if they are visited or water.

2. Step 2: Identify consequence of missing check

   This causes multiple visits to the same cell, increasing runtime and possible infinite loops.

3. Final Answer:

   It does not check if a cell is already visited before pushing neighbors -> Option A

4. Quick Check:

   Check before enqueueing neighbors to avoid repeats [OK]

Hint: Check visited before enqueueing neighbors in BFS [OK]

Common Mistakes:

• Thinking queue.shift() inefficiency is the bug here
• Marking visited after enqueue instead of before
• Confusing recursion with iteration

5. Given a grid where diagonal connections also count as connected land, how would you modify the DFS to count islands correctly?

hard

A. Ignore diagonal neighbors and count only vertical connections

B. Only check horizontal neighbors (r,c+1) and (r,c-1)

C. Add diagonal neighbors (r+1,c+1), (r+1,c-1), (r-1,c+1), (r-1,c-1) to DFS calls

D. Use BFS instead of DFS without changing neighbors

Solution

1. Step 1: Understand connectivity rules

   Diagonal connections mean neighbors include diagonals, not just up/down/left/right.

2. Step 2: Modify DFS to include diagonal neighbors

   Add DFS calls for (r+1,c+1), (r+1,c-1), (r-1,c+1), (r-1,c-1) along with existing neighbors.

3. Final Answer:

   Add diagonal neighbors (r+1,c+1), (r+1,c-1), (r-1,c+1), (r-1,c-1) to DFS calls -> Option C

4. Quick Check:

   Include diagonal neighbors for diagonal connectivity [OK]

Hint: Add diagonal neighbors to DFS for diagonal island counting [OK]

Common Mistakes:

• Ignoring diagonal neighbors when required
• Switching BFS/DFS without changing neighbor logic
• Counting only horizontal or vertical neighbors