Word Search II - Practice Coding Problems

Word Search II - Problem

Array String Backtracking Trie Matrix Hard

Imagine you're a treasure hunter with a grid of letters and a list of secret words to find! Your mission is to discover which words are hidden in the grid by connecting adjacent letters.

Given an m x n board of characters and a list of strings words, return all words that can be found on the board. Each word must be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or vertically neighboring (no diagonal moves allowed). The same letter cell may not be used more than once in a single word.

Example: If your board contains letters arranged in a grid and you're searching for words like "OATH" and "PEA", you need to trace a path through adjacent cells to spell out each word completely.

Input & Output

example_1.py — Basic Grid Search

$ Input: board = [["o","a","a","n"],["e","t","a","e"],["i","h","k","r"],["i","f","l","v"]], words = ["oath","pea","eat","rain"]

› Output: ["eat","oath"]

💡 Note: "eat" can be formed by following path (1,1)→(1,2)→(0,2), and "oath" can be formed by (0,0)→(0,1)→(1,1)→(1,2). "pea" and "rain" cannot be formed on this board.

example_2.py — Single Character Grid

$ Input: board = [["a","b"],["c","d"]], words = ["abcb"]

› Output: []

💡 Note: The word "abcb" cannot be formed because we cannot reuse the same cell. After using 'a'→'b', we cannot go back to use 'b' again.

example_3.py — Multiple Valid Words

$ Input: board = [["o","a","b","n"],["o","t","a","e"],["a","h","k","r"],["a","f","l","v"]], words = ["oa","oaa"]

› Output: ["oa","oaa"]

💡 Note: Both "oa" (from (0,0)→(0,1)) and "oaa" (from (0,0)→(0,1)→(0,2)) can be found in the grid following valid adjacent paths.

Visualization

Tap to expand

Understanding the Visualization

Build the Compass

Create a Trie (prefix tree) containing all treasure words to guide our search

Start Exploration

Begin DFS from each cell on the board, following the Trie's guidance

Smart Pruning

Stop exploring paths early if the Trie indicates no words can be formed

Collect Treasures

When we reach a complete word in the Trie, add it to our treasure collection

Key Takeaway

🎯 Key Insight: The Trie data structure transforms this from multiple separate searches into one intelligent exploration, dramatically reducing the search space through smart pruning!

Time & Space Complexity

Time Complexity

⏱️

O(M × N × 4^L)

M×N cells × 4^L paths, where L is max word length. Trie allows early pruning.

✓ Linear Growth

Space Complexity

O(K × L)

Trie storage for K words with average length L, plus recursion stack

✓ Linear Space

Constraints

m == board.length
n == board[i].length
1 ≤ m, n ≤ 12
board[i][j] is a lowercase English letter
1 ≤ words.length ≤ 3 × 10⁴
1 ≤ words[i].length ≤ 10
words[i] consists of lowercase English letters
All the strings of words are unique

Asked in

G Google 85 a Amazon 72 ⊞ Microsoft 58 f Meta 45 Apple 38

The optimal solution uses a Trie data structure combined with DFS and backtracking. Build a Trie containing all words, then perform DFS from each board cell. The Trie enables early pruning of invalid paths, making this approach significantly faster than searching for each word individually. Time complexity: O(M × N × 4^L) where M×N is board size and L is maximum word length.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Individual Word Search)	O(N × M × 4^L × W)	O(L)	Search for each word individually using DFS from every cell
Trie + DFS (Optimal)	O(M × N × 4^L)	O(K × L)	Build a Trie of all words, then perform single DFS traversal with pruning

Brute Force (Individual Word Search) — Algorithm Steps

For each word in the words list
For each cell in the board as a starting point
Perform DFS to see if we can construct the word
Use backtracking to mark/unmark visited cells
Add found words to the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Word

Choose the first word from the list

Try All Positions

Start DFS from each cell on the board

Explore Paths

Use backtracking to explore all possible paths

Repeat

Repeat for each remaining word

Code -

solution.c — C

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

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

char** findWords(char** board, int boardSize, int* boardColSize, char** words, int wordsSize, int* returnSize) {
    *returnSize = 0;
    if (boardSize == 0 || wordsSize == 0) return NULL;
    
    char** result = (char**)malloc(wordsSize * sizeof(char*));
    
    for (int w = 0; w < wordsSize; w++) {
        bool found = false;
        for (int r = 0; r < boardSize && !found; r++) {
            for (int c = 0; c < boardColSize[r] && !found; c++) {
                if (dfs(board, boardSize, boardColSize, r, c, words[w], 0)) {
                    result[*returnSize] = (char*)malloc((strlen(words[w]) + 1) * sizeof(char));
                    strcpy(result[*returnSize], words[w]);
                    (*returnSize)++;
                    found = true;
                }
            }
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(N × M × 4^L × W)

N×M cells × W words × 4^L DFS paths (L = max word length)

✓ Linear Growth

Space Complexity

O(L)

Recursion depth limited by maximum word length

✓ Linear Space

Constraints

m == board.length
n == board[i].length
1 ≤ m, n ≤ 12
board[i][j] is a lowercase English letter
1 ≤ words.length ≤ 3 × 10⁴
1 ≤ words[i].length ≤ 10
words[i] consists of lowercase English letters
All the strings of words are unique

89.4K Views

High Frequency

~25 min Avg. Time

2.3K 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 (Individual Word Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler