Word Search in Grid Using Backtracking in DSA Javascript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind backtracking in word search problems?

Backtracking tries all possible paths in the grid to find the word by exploring one letter at a time and undoing steps if a path does not lead to a solution.

beginner

In a word search grid, why do we mark cells as visited during backtracking?

We mark cells as visited to avoid using the same letter cell more than once in the current word path, preventing cycles and incorrect matches.

beginner

What directions are typically checked from a cell in a word search backtracking algorithm?

Usually, the algorithm checks up, down, left, and right neighbors to find the next letter in the word.

intermediate

How does backtracking handle a mismatch when searching for a word in the grid?

When a mismatch occurs, backtracking returns false and undoes the last step, allowing the algorithm to try other paths.

advanced

What is the time complexity of the word search backtracking algorithm in an m x n grid for a word of length k?

The worst-case time complexity is O(m * n * 4^k) because from each cell, up to 4 directions are explored for each letter in the word.

What is the purpose of marking a cell as visited in word search backtracking?

A To permanently remove the cell from the grid

B To mark the cell as part of the final answer

C To avoid revisiting the same cell in the current path

D To speed up the search by skipping cells

Marking a cell as visited prevents using the same cell multiple times in the current word path, which is essential to avoid cycles.

Which directions are checked when searching for the next letter in the grid?

A Random directions

B Only diagonals

C Up and left only

D Up, down, left, right

The algorithm checks up, down, left, and right neighbors to find the next letter.

What happens if the current path does not match the word during backtracking?

A The algorithm marks the word as found

B The algorithm backtracks and tries other paths

C The algorithm stops immediately

D The algorithm skips the current letter

Backtracking undoes the last step and tries other possible paths when a mismatch occurs.

What is the base case for the recursive backtracking function in word search?

A All letters of the word are found

B The grid is empty

C No neighbors are left

D The first letter is found

The base case is when all letters of the word have been matched successfully.

What is the worst-case time complexity of word search backtracking for a word of length k in an m x n grid?

A O(m * n * 4^k)

B O(k * m * n)

C O(m + n + k)

D O(m * n)

From each cell, up to 4 directions are explored for each letter, leading to O(m * n * 4^k) complexity.

Explain how backtracking works to find a word in a grid.

Think about trying paths and undoing steps when stuck.

Describe why marking cells as visited is important in word search backtracking.

Imagine walking on a path without stepping on the same stone twice.

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