Word Search

Word Search - Problem

Given an m x n grid of characters board and a string word, return true if word exists in the grid.

The word can 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.

Input & Output

Example 1 — Found Word

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

› Output: true

💡 Note: Path exists: A(0,0) → B(0,1) → C(0,2) → C(1,2) → E(2,2) → D(2,1). Each step moves to adjacent cell without reusing.

Example 2 — Word Not Found

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

› Output: false

💡 Note: Cannot form ABCB because after A(0,0) → B(0,1) → C(0,2), we need another B but the original B(0,1) cannot be reused.

Example 3 — Single Character

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

› Output: true

💡 Note: Single cell matches single character word perfectly.

Constraints

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

Visualization

Tap to expand

Asked in

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

The key insight is to use backtracking DFS from each cell, marking visited cells and unmarking during backtrack. Optimizations include character frequency pre-check and starting from less frequent character end. Best approach uses DFS with backtracking. Time: O(m × n × 4^L), Space: O(L)

Common Approaches

✓ Brute Force with DFS

⏱️ Time: O(m × n × 4^L) Space: O(L)

For each cell in the grid, attempt to build the target word by exploring all four directions recursively. Use a visited array to track used cells.

Optimized Backtracking

⏱️ Time: O(m × n × 4^L) Space: O(L)

Enhanced version with optimizations like early character frequency check and better pruning strategies to reduce unnecessary exploration.

Brute Force with DFS — Algorithm Steps

Iterate through each cell as potential starting point
For each starting cell, perform DFS in all 4 directions
Mark cells as visited during exploration, unmark when backtracking

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Try each cell as starting point

Explore

DFS in 4 directions, mark visited

Backtrack

Unmark cell when returning from recursion

Code -

solution.c — C

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

typedef struct {
    int r, c;
} Pair;

bool contains(Pair* visited, int visitedSize, int r, int c) {
    for (int i = 0; i < visitedSize; i++) {
        if (visited[i].r == r && visited[i].c == c) {
            return true;
        }
    }
    return false;
}

bool dfs(int r, int c, int index, Pair* visited, int* visitedSize, char** board, int rows, int cols, char* word) {
    if (index == strlen(word)) {
        return true;
    }
    
    if (r < 0 || r >= rows || c < 0 || c >= cols || 
        contains(visited, *visitedSize, r, c) || board[r][c] != word[index]) {
        return false;
    }
    
    // Mark as visited
    visited[*visitedSize].r = r;
    visited[*visitedSize].c = c;
    (*visitedSize)++;
    
    // Explore all 4 directions
    bool result = false;
    int directions[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    for (int i = 0; i < 4; i++) {
        if (dfs(r + directions[i][0], c + directions[i][1], index + 1, visited, visitedSize, board, rows, cols, word)) {
            result = true;
            break;
        }
    }
    
    // Backtrack
    (*visitedSize)--;
    return result;
}

bool solution(char** board, int rows, int cols, char* word) {
    if (board == NULL || rows == 0 || cols == 0 || word == NULL || strlen(word) == 0) {
        return false;
    }
    
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            Pair visited[1000];
            int visitedSize = 0;
            if (dfs(i, j, 0, visited, &visitedSize, board, rows, cols, word)) {
                return true;
            }
        }
    }
    
    return false;
}

void parseBoard(char* line, char*** board, int* rows, int* cols) {
    *board = malloc(10 * sizeof(char*));
    *rows = 0;
    *cols = 0;
    
    const char* p = line;
    // Skip to first '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        
        if (*p == '[') {
            p++; // Skip '['
            (*board)[*rows] = malloc(10 * sizeof(char));
            int colCount = 0;
            
            while (*p && *p != ']') {
                // Skip whitespace and commas
                while (*p == ' ' || *p == ',') p++;
                
                if (*p == '"') {
                    p++; // Skip opening quote
                    if (*p != '"' && *p != ',' && *p != ']' && *p != '\0') {
                        (*board)[*rows][colCount] = *p;
                        colCount++;
                        p++; // Move past the character
                    }
                    // Skip closing quote if present
                    if (*p == '"') p++;
                } else {
                    p++;
                }
            }
            
            if (*p == ']') p++; // Skip ']'
            if (*rows == 0) *cols = colCount;
            (*rows)++;
        } else {
            p++;
        }
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    char word[100];
    fgets(word, sizeof(word), stdin);
    word[strcspn(word, "\n")] = 0;
    
    char** board;
    int rows, cols;
    
    parseBoard(line, &board, &rows, &cols);
    
    bool result = solution(board, rows, cols, word);
    printf("%s\n", result ? "true" : "false");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n × 4^L)

For each cell (m×n), we may explore 4 directions up to L times where L is word length

✓ Linear Growth

Space Complexity

O(L)

Recursion stack depth equals word length L

✓ Linear Space

89.2K Views

High Frequency

~25 min Avg. Time

2.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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler