Word Search II

Word Search II - Problem

Array String Backtracking Trie Matrix Hard

Given an m x n board of characters and a list of strings words, return all words on the board.

Each word must be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or vertically neighboring. The same letter cell may not be used more than once in a word.

Input & Output

Example 1 — Basic Word 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: e(1,0)→a(1,2)→t(1,1). "oath" can be formed: o(0,0)→a(0,1)→t(1,1)→h(2,1). "pea" and "rain" cannot be formed on this board.

Example 2 — Single Character Board

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

› Output: []

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

Example 3 — Multiple Short Words

$ Input: board = [["a","a"]], words = ["a","aa","aaa"]

› Output: ["a","aa"]

💡 Note: "a" can be formed using either cell. "aa" can be formed using both cells a(0,0)→a(0,1). "aaa" cannot be formed as we only have 2 'a' characters.

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

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is using a Trie (prefix tree) to eliminate redundant prefix searches and enable early termination when no valid word prefixes exist. Best approach combines Trie construction with DFS backtracking for optimal performance. Time: O(M × N × 4^L), Space: O(W × L)

Common Approaches

✓ Brute Force - Individual Word Search

⏱️ Time: O(W × M × N × 4^L) Space: O(L)

For each word in the list, perform a separate DFS search starting from every cell in the board. Use backtracking to explore all possible paths while marking visited cells.

Optimized Trie + Backtracking

⏱️ Time: O(M × N × 4^L + W × L) Space: O(W × L)

Construct a Trie (prefix tree) from all words, then perform a single DFS traversal of the board. During DFS, traverse the Trie simultaneously to check if current path forms valid word prefixes.

Brute Force - Individual Word Search — Algorithm Steps

Step 1: For each word, try starting from every board cell
Step 2: Use DFS with backtracking to match word characters
Step 3: Mark cells as visited during search, unmark on backtrack

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Search

For each word, try every board position as starting point

DFS Exploration

Use depth-first search with backtracking to match characters

Collect Results

Add found words to result list

Code -

solution.c — C

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

#define MAX_WORDS 100
#define MAX_WORD_LEN 100
#define MAX_BOARD_SIZE 100
#define MAX_VISITED 10000

typedef struct {
    int i, j;
} Position;

bool dfs(char board[MAX_BOARD_SIZE][MAX_BOARD_SIZE], int m, int n, int i, int j, const char* word, int index, Position* visited, int* visitedSize) {
    if (index == strlen(word)) {
        return true;
    }
    if (i < 0 || i >= m || j < 0 || j >= n) {
        return false;
    }
    
    // Check if position is already visited
    for (int k = 0; k < *visitedSize; k++) {
        if (visited[k].i == i && visited[k].j == j) {
            return false;
        }
    }
    
    if (board[i][j] != word[index]) {
        return false;
    }
    
    // Add to visited
    visited[*visitedSize].i = i;
    visited[*visitedSize].j = j;
    (*visitedSize)++;
    
    bool found = dfs(board, m, n, i+1, j, word, index+1, visited, visitedSize) ||
                 dfs(board, m, n, i-1, j, word, index+1, visited, visitedSize) ||
                 dfs(board, m, n, i, j+1, word, index+1, visited, visitedSize) ||
                 dfs(board, m, n, i, j-1, word, index+1, visited, visitedSize);
    
    // Remove from visited
    (*visitedSize)--;
    return found;
}

int solution(char board[MAX_BOARD_SIZE][MAX_BOARD_SIZE], int m, int n, char words[MAX_WORDS][MAX_WORD_LEN], int wordsSize, char result[MAX_WORDS][MAX_WORD_LEN]) {
    if (m == 0 || n == 0 || wordsSize == 0) {
        return 0;
    }
    
    int resultSize = 0;
    
    for (int w = 0; w < wordsSize; w++) {
        bool found = false;
        for (int i = 0; i < m && !found; i++) {
            for (int j = 0; j < n && !found; j++) {
                Position visited[MAX_VISITED];
                int visitedSize = 0;
                if (dfs(board, m, n, i, j, words[w], 0, visited, &visitedSize)) {
                    strcpy(result[resultSize], words[w]);
                    resultSize++;
                    found = true;
                }
            }
        }
    }
    
    // Sort result
    for (int i = 0; i < resultSize - 1; i++) {
        for (int j = i + 1; j < resultSize; j++) {
            if (strcmp(result[i], result[j]) > 0) {
                char temp[MAX_WORD_LEN];
                strcpy(temp, result[i]);
                strcpy(result[i], result[j]);
                strcpy(result[j], temp);
            }
        }
    }
    
    return resultSize;
}

int main() {
    char line[10000];
    char board[MAX_BOARD_SIZE][MAX_BOARD_SIZE];
    char words[MAX_WORDS][MAX_WORD_LEN];
    char result[MAX_WORDS][MAX_WORD_LEN];
    
    // Read board
    fgets(line, sizeof(line), stdin);
    
    int m = 0, n = 0;
    char* ptr = line;
    
    // Skip to first row
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr && *ptr != ']') {
        // Skip to start of row
        while (*ptr && *ptr != '[') ptr++;
        if (*ptr == '[') ptr++;
        
        n = 0;
        while (*ptr && *ptr != ']') {
            if (*ptr >= 'a' && *ptr <= 'z') {
                board[m][n] = *ptr;
                n++;
            }
            ptr++;
        }
        if (*ptr == ']') ptr++;
        
        if (n > 0) m++;
    }
    
    // Read words
    fgets(line, sizeof(line), stdin);
    
    int wordsSize = 0;
    ptr = line;
    
    // Skip to first word
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr && *ptr != ']') {
        // Skip to start of word
        while (*ptr && *ptr != '"') ptr++;
        if (*ptr == '"') ptr++;
        
        int wordLen = 0;
        while (*ptr && *ptr != '"') {
            words[wordsSize][wordLen] = *ptr;
            wordLen++;
            ptr++;
        }
        words[wordsSize][wordLen] = '\0';
        
        if (wordLen > 0) wordsSize++;
        
        if (*ptr == '"') ptr++;
        while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
    }
    
    int resultSize = solution(board, m, n, words, wordsSize, result);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < resultSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

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

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

✓ Linear Growth

Space Complexity

O(L)

Recursion stack depth equals maximum word length

✓ Linear Space

186.6K Views

High Frequency

~35 min Avg. Time

3.4K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Individual Word Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler