Check if Word Can Be Placed In Crossword - Problem

You are given an m x n matrix board, representing the current state of a crossword puzzle. The crossword contains lowercase English letters (from solved words), ' ' to represent any empty cells, and '#' to represent any blocked cells.

A word can be placed horizontally (left to right or right to left) or vertically (top to bottom or bottom to top) in the board if:

It does not occupy a cell containing the character '#'.
The cell each letter is placed in must either be ' ' (empty) or match the letter already on the board.
There must not be any empty cells ' ' or other lowercase letters directly left or right of the word if the word was placed horizontally.
There must not be any empty cells ' ' or other lowercase letters directly above or below the word if the word was placed vertically.

Given a string word, return true if word can be placed in board, or false otherwise.

Input & Output

Example 1 — Word Fits Vertically

$ Input: board = [["#", " ", "#"], [" ", " ", "#"], ["#", "c", " "]], word = "abc"

› Output: true

💡 Note: The word "abc" can be placed vertically in column 1: board[0][1]=' ' becomes 'a', board[1][1]=' ' becomes 'b', board[2][1]='c' stays 'c'. The placement is valid as it's bounded by '#' cells.

Example 2 — Word Fits Horizontally

$ Input: board = [[" ", "#", "a"], [" ", "#", "c"], [" ", "#", "a"]], word = "ac"

› Output: false

💡 Note: The word "ac" cannot be placed anywhere on the board. No horizontal slots of length 2 exist due to '#' separators. Column 0 has 3 empty spaces but lacks proper boundaries (no '#' above or below the board). Column 2 contains ['a','c','a'] but "ac" doesn't match any 2-character substring.

Example 3 — No Valid Placement

$ Input: board = [["#", "#", "#"], [" ", " ", " "], ["#", "#", "#"]], word = "abc"

› Output: false

💡 Note: The word "abc" has length 3, but the only available slot is the middle row with length 3. However, there are no boundaries ('#') at the ends of this slot, so the word cannot be placed.

Constraints

m == board.length
n == board[i].length
1 ≤ m, n ≤ 20
board[i][j] will be ' ', '#', or a lowercase English letter
1 ≤ word.length ≤ max(m, n)

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6 A Apple 4

The key insight is that a word can only be placed in continuous slots that are exactly bounded by '#' cells or board edges. The optimal approach systematically finds all valid slots of the correct length, then checks if the word characters are compatible (empty or matching). Time: O(m×n×L), Space: O(1).

Common Approaches

✓ Brute Force Enumeration

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

For each cell in the board, try placing the word horizontally (left-to-right and right-to-left) and vertically (top-to-bottom and bottom-to-top). Check if the placement is valid according to all the crossword rules.

Optimized Slot Finding

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

Instead of checking every position, first identify all valid slots (continuous sequences bounded by '#' or edges) that match the word length, then check if the word can be placed in each slot.

Brute Force Enumeration — Algorithm Steps

Iterate through each cell (i, j) in the board
For each cell, try all 4 directions: horizontal left-to-right, right-to-left, vertical top-to-bottom, bottom-to-top
For each direction, check if word can be placed starting at (i, j)
Validate: no '#' cells, letters match or are empty, proper boundaries

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Position

Try placing word at each cell

Test Directions

For each cell, test horizontal and vertical placements

Validate

Check boundaries and character compatibility

Code -

solution.c — C

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

bool canPlaceHorizontal(char board[][1000], int m, int n, char* word, int row, int col, int direction) {
    int wordLen = strlen(word);
    int startCol = direction == 1 ? col : col - wordLen + 1;
    
    if (startCol < 0 || startCol + wordLen > n) return false;
    
    if (startCol > 0 && board[row][startCol - 1] != '#') return false;
    if (startCol + wordLen < n && board[row][startCol + wordLen] != '#') return false;
    
    for (int i = 0; i < wordLen; i++) {
        char cell = board[row][startCol + i];
        if (cell == '#' || (cell != ' ' && cell != word[i])) return false;
    }
    return true;
}

bool canPlaceVertical(char board[][1000], int m, int n, char* word, int row, int col, int direction) {
    int wordLen = strlen(word);
    int startRow = direction == 1 ? row : row - wordLen + 1;
    
    if (startRow < 0 || startRow + wordLen > m) return false;
    
    if (startRow > 0 && board[startRow - 1][col] != '#') return false;
    if (startRow + wordLen < m && board[startRow + wordLen][col] != '#') return false;
    
    for (int i = 0; i < wordLen; i++) {
        char cell = board[startRow + i][col];
        if (cell == '#' || (cell != ' ' && cell != word[i])) return false;
    }
    return true;
}

bool solution(char board[][1000], int m, int n, char* word) {
    if (m == 0 || n == 0 || strlen(word) == 0) return false;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (canPlaceHorizontal(board, m, n, word, i, j, 1) ||
                canPlaceHorizontal(board, m, n, word, i, j, -1) ||
                canPlaceVertical(board, m, n, word, i, j, 1) ||
                canPlaceVertical(board, m, n, word, i, j, -1)) {
                return true;
            }
        }
    }
    return false;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    static char board[1000][1000];
    int m = 0, n = 0;
    
    // Parse board
    int pos = 0;
    int currentRow = 0;
    int currentCol = 0;
    bool inQuote = false;
    bool expectingChar = false;
    bool firstRow = true;
    
    while (line[pos] != '\0' && line[pos] != '\n') {
        char c = line[pos];
        if (c == '"') {
            if (inQuote) {
                inQuote = false;
                expectingChar = false;
            } else {
                inQuote = true;
                expectingChar = true;
            }
        } else if (inQuote && expectingChar) {
            board[currentRow][currentCol] = c;
            currentCol++;
            if (firstRow) n = currentCol;
            expectingChar = false;
        } else if (c == ']' && currentCol > 0) {
            currentRow++;
            currentCol = 0;
            firstRow = false;
        }
        pos++;
    }
    m = currentRow;
    
    fgets(line, sizeof(line), stdin);
    // Remove newline
    int len = strlen(line);
    if (len > 0 && line[len-1] == '\n') {
        line[len-1] = '\0';
    }
    
    bool result = solution(board, m, n, line);
    printf("%s\n", result ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n × L)

For each cell (m×n), we check 4 directions, each taking O(L) time where L is word length

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

842 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

Check if Word Can Be Placed In Crossword - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler