Word Search - Practice Coding Problems

Word Search - Problem

Imagine you're solving a word search puzzle from your favorite magazine! Given an m × n grid filled with letters and a target word, your mission is to determine if the word exists somewhere in the grid.

The rules are simple but important:
• You can only move to adjacent cells (horizontally or vertically neighboring)
• Each letter cell can only be used once per word
• You need to find the complete word following a valid path

Return true if the word exists in the grid, false otherwise. This classic puzzle combines backtracking and depth-first search - perfect for practicing recursive algorithms!

Input & Output

example_1.py — Basic word found

$ Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"

› Output: true

💡 Note: The word "ABCCED" can be found by starting at (0,0) and following the path: A(0,0) → B(0,1) → C(0,2) → C(1,2) → E(2,2) → D(2,1). Each cell is used exactly once.

example_2.py — Word not found

$ Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCB"

› Output: false

💡 Note: The word "ABCB" cannot be found. While we can start A(0,0) → B(0,1) → C(0,2), there's no way to reach another 'B' without reusing the B at (0,1), which violates the rule.

example_3.py — Single character

$ Input: board = [["A"]], word = "A"

› Output: true

💡 Note: Simple case: the single cell contains the target word 'A', so it's found immediately.

Visualization

Tap to expand

Understanding the Visualization

Find starting points

Look for cells containing the first letter of your word

Explore paths

From each starting point, use DFS to explore adjacent cells

Mark territory

Mark each cell as visited to avoid reusing it in the current path

Backtrack smartly

If a path fails, unmark cells and try a different direction

Success or retry

Return true when word is complete, or try next starting point

Key Takeaway

🎯 Key Insight: Use DFS with backtracking, but be smart about starting points - only begin from cells that match the first character of your target word!

Time & Space Complexity

Time Complexity

⏱️

O(m × n × 4^L)

For each of the m×n cells, we potentially explore 4^L paths where L is word length

✓ Linear Growth

Space Complexity

O(L)

Recursion stack depth equals the length of the word

✓ Linear Space

Constraints

m == board.length
n = board[i].length
1 ≤ m, n ≤ 6
1 ≤ word.length ≤ 15
board and word consist of only lowercase and uppercase English letters

Asked in

f Meta 45 ⊞ Microsoft 38 a Amazon 32 G Google 28

The optimal approach uses DFS with backtracking starting only from cells that match the first character. Key insights: mark cells as visited during exploration, unmark when backtracking to allow reuse in other paths, and filter starting points to avoid unnecessary searches. Time complexity: O(N × 4^L) where N is valid starting points and L is word length.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force DFS from Every Cell	O(m × n × 4^L)	O(L)	Try starting the word search from every single cell in the grid
Optimized DFS with Smart Starting Points	O(N × 4^L)	O(L)	Only start DFS from cells that match the first character of the word

Brute Force DFS from Every Cell — Algorithm Steps

Iterate through every cell in the grid as a potential starting point
For each cell, start a DFS to try to match the entire word
Use backtracking: mark visited cells and unmark when backtracking
Explore all four directions (up, down, left, right) from each cell
Return true if any starting position successfully finds the word

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from every cell

Try each cell as potential starting point

DFS exploration

Use DFS with backtracking from each starting point

Mark and unmark

Mark cells as visited, then unmark when backtracking

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>
#include <string.h>

bool dfs(char** board, int boardSize, int* boardColSize, char* word, int r, int c, int index) {
    if (index == strlen(word)) return true;
    
    if (r < 0 || r >= boardSize || c < 0 || c >= boardColSize[0] ||
        board[r][c] != word[index] || board[r][c] == '#') {
        return false;
    }
    
    char temp = board[r][c];
    board[r][c] = '#';
    
    bool found = dfs(board, boardSize, boardColSize, word, r+1, c, index+1) ||
                dfs(board, boardSize, boardColSize, word, r-1, c, index+1) ||
                dfs(board, boardSize, boardColSize, word, r, c+1, index+1) ||
                dfs(board, boardSize, boardColSize, word, r, c-1, index+1);
    
    board[r][c] = temp;
    return found;
}

bool exist(char** board, int boardSize, int* boardColSize, char* word) {
    if (boardSize == 0 || boardColSize[0] == 0 || strlen(word) == 0) return false;
    
    for (int i = 0; i < boardSize; i++) {
        for (int j = 0; j < boardColSize[0]; j++) {
            if (dfs(board, boardSize, boardColSize, word, i, j, 0)) {
                return true;
            }
        }
    }
    return false;
}

int main() {
    char* board[] = {"ABCE", "SFCS", "ADEE"};
    int boardSize = 3;
    int boardColSize[] = {4, 4, 4};
    char* word = "ABCCED";
    printf("%d\n", exist(board, boardSize, boardColSize, word));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n × 4^L)

For each of the m×n cells, we potentially explore 4^L paths where L is word length

✓ Linear Growth

Space Complexity

O(L)

Recursion stack depth equals the length of the word

✓ Linear Space

Constraints

m == board.length
n = board[i].length
1 ≤ m, n ≤ 6
1 ≤ word.length ≤ 15
board and word consist of only lowercase and uppercase English letters

52.3K Views

High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force DFS from Every Cell — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler