Word Search in Grid Using Backtracking in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if the current cell matches the first letter of the word.

DSA Javascript

if (board[row][col] === word[[1]]) {

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

A0

B1

Cword.length - 1

Dword.length

Attempts:

3 left

💡 Hint

Common Mistakes

Using index 1 instead of 0 causes skipping the first letter.

Using word.length causes out-of-bound error.

The search starts by matching the first letter of the word, which is at index 0.

2fill in blank

medium

Complete the code to mark the current cell as visited during backtracking.

DSA Javascript

board[row][col] = [1];

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

Anull

Bword[index]

C'#'

D''

Attempts:

3 left

💡 Hint

Common Mistakes

Setting cell to null or empty string may cause confusion with valid letters.

Not marking visited cells leads to infinite loops.

Marking the cell with '#' prevents revisiting it during the current search path.

3fill in blank

hard

Fix the error in the recursive call to search the next letter in all 4 directions.

DSA Javascript

return dfs(board, word, row + [1], col) || dfs(board, word, row - [2], col) || dfs(board, word, row, col + 1) || dfs(board, word, row, col - 1);

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

A1

B-1

C0

D2

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 or 2 causes no movement or skipping cells.

Using negative values incorrectly swaps directions.

To move down, add 1 to row; to move up, subtract 1 from row. The first blank needs 1 and the second blank needs -1 respectively.

4fill in blank

hard

Fill both blanks to restore the original letter after backtracking and to check boundary conditions.

DSA Javascript

board[row][col] = [1];
if (row < 0 || row >= board.length || col < 0 || col >= [2]) return false;

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

Aword[index]

Bboard[0].length

Cboard.length

Dword.length

Attempts:

3 left

💡 Hint

Common Mistakes

Restoring with wrong letter causes incorrect board state.

Using board.length for columns causes index errors.

Restore the original letter from word[index]. The column boundary is board[0].length.

5fill in blank

hard

Fill all three blanks to complete the main function that starts the search for the word in the grid.

DSA Javascript

for (let row = 0; row < [1]; row++) {
  for (let col = 0; col < [2]; col++) {
    if (dfs(board, word, row, col, [3])) return true;
  }
}
return false;

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

Aboard.length

B0

Cboard[0].length

Dword

Attempts:

3 left

💡 Hint

Common Mistakes

Using word length for loops causes index errors.

Starting dfs with wrong index skips letters.

Loop rows with board.length, columns with board[0].length, and start dfs with index 0 of the word.

Practice

1. What is the main purpose of using backtracking in a word search grid problem?

easy

A. To sort the grid alphabetically

B. To count the number of words in the grid

C. To explore all possible paths to find the word

D. To replace characters in the grid

Solution

1. Step 1: Understand backtracking in word search

   Backtracking tries all possible paths in the grid to find the target word by exploring neighbors recursively.

2. Step 2: Eliminate other options

   Sorting, counting words, or replacing characters are not related to backtracking's purpose in this problem.

3. Final Answer:

   To explore all possible paths to find the word -> Option C

4. Quick Check:

   Backtracking = Explore paths [OK]

Hint: Backtracking means trying all paths step-by-step [OK]

Common Mistakes:

• Thinking backtracking sorts or modifies the grid
• Confusing backtracking with simple searching
• Assuming backtracking counts words directly

2. Which of the following is the correct way to check if a position (row, col) is inside the grid boundaries in JavaScript?

easy

A. if (row > 0 && row <= grid.length && col > 0 && col <= grid[0].length)

B. if (row >= 0 && row < grid.length && col >= 0 && col < grid[0].length)

C. if (row >= 0 && row <= grid.length && col >= 0 && col <= grid[0].length)

D. if (row > 0 && row < grid.length && col > 0 && col < grid[0].length)

Solution

1. Step 1: Understand grid indexing

   Grid rows and columns start at 0 and go up to length - 1, so valid indices satisfy 0 <= row < length.

2. Step 2: Check each option

   if (row >= 0 && row < grid.length && col >= 0 && col < grid[0].length) correctly uses >= 0 and < length. Others use > 0 or <= length, which are incorrect for zero-based indexing.

3. Final Answer:

   if (row >= 0 && row < grid.length && col >= 0 && col < grid[0].length) -> Option B

4. Quick Check:

   Check boundaries with >=0 and < length [OK]

Hint: Use zero-based indexing: start at 0, less than length [OK]

Common Mistakes:

• Using > 0 excludes first row/column
• Using <= length allows out-of-bound index
• Confusing inclusive and exclusive bounds

3. What will be the output of the following code snippet when searching for the word "CAT" in the given grid?

const grid = [
  ['C', 'A', 'T'],
  ['A', 'T', 'C'],
  ['T', 'C', 'A']
];

function exist(board, word) {
  const rows = board.length;
  const cols = board[0].length;
  const visited = Array.from({ length: rows }, () => Array(cols).fill(false));

  function backtrack(r, c, index) {
    if (index === word.length) return true;
    if (r < 0 || c < 0 || r >= rows || c >= cols) return false;
    if (visited[r][c] || board[r][c] !== word[index]) return false;

    visited[r][c] = true;
    const res = backtrack(r + 1, c, index + 1) || backtrack(r - 1, c, index + 1) || backtrack(r, c + 1, index + 1) || backtrack(r, c - 1, index + 1);
    visited[r][c] = false;
    return res;
  }

  for (let i = 0; i < rows; i++) {
    for (let j = 0; j < cols; j++) {
      if (backtrack(i, j, 0)) return true;
    }
  }
  return false;
}

console.log(exist(grid, "CAT"));

medium

A. true

B. false

C. SyntaxError

D. undefined

Solution

1. Step 1: Trace the backtracking search for "CAT"

   The word "CAT" can be found starting at grid[0][0] = 'C', then right to 'A', then right to 'T'. The function returns true.

2. Step 2: Confirm no errors and correct return

   The code correctly marks visited cells and explores neighbors. It returns true when the word is found.

3. Final Answer:

   true -> Option A

4. Quick Check:

   Word "CAT" found in grid = true [OK]

Hint: Check neighbors recursively for each letter [OK]

Common Mistakes:

• Ignoring visited array causing infinite loops
• Not checking all directions
• Assuming word must be in a straight line only

4. Identify the bug in the following backtracking function for word search and select the fix.

function backtrack(r, c, index) {
  if (index === word.length) return true;
  if (r < 0 || c < 0 || r >= rows || c >= cols) return false;
  if (board[r][c] !== word[index]) return false;

  visited[r][c] = true;
  const res = backtrack(r + 1, c, index + 1) || backtrack(r - 1, c, index + 1) || backtrack(r, c + 1, index + 1) || backtrack(r, c - 1, index + 1);
  return res;
}

medium

A. Change the base case to index > word.length

B. Remove the boundary checks for r and c

C. Remove the visited array usage completely

D. Add visited[r][c] = false after recursive calls to unmark

Solution

1. Step 1: Identify missing backtracking step

   The function marks visited[r][c] = true but never resets it to false after recursion, causing wrong results.

2. Step 2: Fix by unmarking visited after recursion

   Adding visited[r][c] = false after recursive calls allows other paths to use this cell again.

3. Final Answer:

   Add visited[r][c] = false after recursive calls to unmark -> Option D

4. Quick Check:

   Unmark visited after recursion to backtrack [OK]

Hint: Always reset visited after recursion to explore other paths [OK]

Common Mistakes:

• Forgetting to unmark visited cells
• Removing boundary checks causing errors
• Changing base case incorrectly

5. Given a grid and a list of words, how would you efficiently find all words present in the grid using backtracking? Choose the best approach.

hard

A. Use a Trie (prefix tree) to reduce repeated searches and backtrack once

B. Run backtracking separately for each word on the entire grid

C. Sort the words and grid alphabetically before searching

D. Replace all grid letters with the first letter of each word before searching

Solution

1. Step 1: Understand inefficiency of separate searches

   Running backtracking for each word separately repeats many searches, wasting time.

2. Step 2: Use Trie to optimize search

   Building a Trie of all words allows backtracking once, pruning paths that don't match any prefix, improving efficiency.

3. Final Answer:

   Use a Trie (prefix tree) to reduce repeated searches and backtrack once -> Option A

4. Quick Check:

   Trie + backtracking = efficient multi-word search [OK]

Hint: Use Trie to share prefixes and avoid repeated searches [OK]

Common Mistakes:

• Searching each word independently causing slow performance
• Sorting grid or words doesn't help search
• Modifying grid letters breaks correctness