Crossword Filler - Problem

You are given a crossword puzzle grid and a list of words to fill it with. The grid contains empty cells (represented by 0) and blocked cells (represented by 1). Your task is to place all the given words in the grid such that:

Words can be placed horizontally (left to right) or vertically (top to bottom)

Words must fit entirely within consecutive empty cells

All words must be used exactly once

Return the filled grid where words are represented by their characters, blocked cells remain as 1, and any remaining empty cells are 0. If no valid arrangement exists, return an empty array.

Input & Output

Example 1 — Basic 3x4 Grid

$ Input: grid = [[0,1,0,0],[0,0,0,0],[0,0,1,0]], words = ["CAT","GO"]

› Output: [["C",1,"G","O"],["A",0,0,0],["T",0,1,0]]

💡 Note: CAT placed vertically at (0,0) and GO placed horizontally at (0,2). Both words fit perfectly in the available slots.

Example 2 — Intersecting Words

$ Input: grid = [[0,0,0],[0,0,0],[0,0,0]], words = ["AB","AC"]

› Output: [["A","B",0],["C",0,0],[0,0,0]]

💡 Note: AB placed horizontally at (0,0) and AC placed vertically at (0,0). They share the letter A at position (0,0).

Example 3 — No Solution

$ Input: grid = [[0,1,0],[1,1,1],[0,1,0]], words = ["HELLO"]

› Output: []

💡 Note: No continuous slot is long enough to fit the 5-letter word HELLO. Return empty array.

Constraints

1 ≤ grid.length, grid[0].length ≤ 20
1 ≤ words.length ≤ 10
1 ≤ words[i].length ≤ 20
grid[i][j] is 0 or 1
words[i] contains only uppercase letters

Visualization

Tap to expand

Asked in

G Google 23 M Microsoft 18 a Amazon 15 f Facebook 12

The key insight is using systematic backtracking with constraint checking to avoid trying invalid word placements. The optimal approach pre-computes valid slots for each word and uses the most constrained word first to minimize the search space. Time: O(n! × m), Space: O(n × m)

Common Approaches

✓ Optimized Backtracking

⏱️ Time: O(n! × m) Space: O(n × m)

Find valid slots for each word first, then use systematic backtracking to try placements. Prune invalid branches early to reduce search space.

Try All Possible Placements

⏱️ Time: O(n! × m²) Space: O(n × m²)

For each word, attempt to place it at every cell in both horizontal and vertical directions. Use recursion to try all combinations, backtracking when placement fails.

Optimized Backtracking — Algorithm Steps

Pre-compute valid slots for each word
Use most constrained word first
Place word and recursively solve remaining
Backtrack efficiently when conflicts arise

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Valid Slots

Pre-compute all horizontal and vertical slots that can fit words

Most Constrained First

Choose word with fewest placement options to reduce search space

Smart Backtracking

Only try valid placements, backtrack efficiently on conflicts

Code -

solution.c — C

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

#define MAX_WORDS 20
#define MAX_WORD_LEN 20
#define MAX_GRID_SIZE 20
#define MAX_SLOTS 100

typedef struct {
    char direction;
    int row, col, length;
} Slot;

typedef struct {
    int direction, row, col;
} WordSlot;

int findHorizontalSlots(int grid[][MAX_GRID_SIZE], int rows, int cols, Slot* slots) {
    int count = 0;
    for (int r = 0; r < rows; r++) {
        int start = -1;
        for (int c = 0; c <= cols; c++) {
            if (c == cols || grid[r][c] == 1) {
                if (start != -1 && c - start >= 2) {
                    slots[count++] = (Slot){'H', r, start, c - start};
                }
                start = -1;
            } else if (start == -1) {
                start = c;
            }
        }
    }
    return count;
}

int findVerticalSlots(int grid[][MAX_GRID_SIZE], int rows, int cols, Slot* slots) {
    int count = 0;
    for (int c = 0; c < cols; c++) {
        int start = -1;
        for (int r = 0; r <= rows; r++) {
            if (r == rows || grid[r][c] == 1) {
                if (start != -1 && r - start >= 2) {
                    slots[count++] = (Slot){'V', start, c, r - start};
                }
                start = -1;
            } else if (start == -1) {
                start = r;
            }
        }
    }
    return count;
}

int canPlaceWord(int grid[][MAX_GRID_SIZE], char* word, char direction, int r, int c) {
    int len = strlen(word);
    if (direction == 'H') {
        for (int i = 0; i < len; i++) {
            if (grid[r][c + i] != 0 && grid[r][c + i] != word[i]) {
                return 0;
            }
        }
    } else {
        for (int i = 0; i < len; i++) {
            if (grid[r + i][c] != 0 && grid[r + i][c] != word[i]) {
                return 0;
            }
        }
    }
    return 1;
}

void placeWord(int grid[][MAX_GRID_SIZE], char* word, char direction, int r, int c, int* original) {
    int len = strlen(word);
    if (direction == 'H') {
        for (int i = 0; i < len; i++) {
            original[i] = grid[r][c + i];
            grid[r][c + i] = word[i];
        }
    } else {
        for (int i = 0; i < len; i++) {
            original[i] = grid[r + i][c];
            grid[r + i][c] = word[i];
        }
    }
}

void removeWord(int grid[][MAX_GRID_SIZE], char* word, char direction, int r, int c, int* original) {
    int len = strlen(word);
    if (direction == 'H') {
        for (int i = 0; i < len; i++) {
            grid[r][c + i] = original[i];
        }
    } else {
        for (int i = 0; i < len; i++) {
            grid[r + i][c] = original[i];
        }
    }
}

int backtrackSolution(int grid[][MAX_GRID_SIZE], char words[][MAX_WORD_LEN], 
                     WordSlot wordSlots[][MAX_SLOTS], int slotCounts[], 
                     int used[], int wordIdx, int numWords) {
    if (wordIdx == numWords) return 1;
    
    // Find next unused word
    int bestWord = -1;
    for (int i = 0; i < numWords; i++) {
        if (!used[i]) {
            bestWord = i;
            break;
        }
    }
    
    if (bestWord == -1) return 0;
    
    used[bestWord] = 1;
    int original[MAX_WORD_LEN];
    
    for (int i = 0; i < slotCounts[bestWord]; i++) {
        WordSlot slot = wordSlots[bestWord][i];
        if (canPlaceWord(grid, words[bestWord], slot.direction, slot.row, slot.col)) {
            placeWord(grid, words[bestWord], slot.direction, slot.row, slot.col, original);
            if (backtrackSolution(grid, words, wordSlots, slotCounts, used, wordIdx + 1, numWords)) {
                return 1;
            }
            removeWord(grid, words[bestWord], slot.direction, slot.row, slot.col, original);
        }
    }
    
    used[bestWord] = 0;
    return 0;
}

int solution(int grid[][MAX_GRID_SIZE], char words[][MAX_WORD_LEN], int rows, int cols, int numWords) {
    if (rows == 0 || numWords == 0) return 0;
    
    Slot horizontalSlots[MAX_SLOTS], verticalSlots[MAX_SLOTS];
    int hCount = findHorizontalSlots(grid, rows, cols, horizontalSlots);
    int vCount = findVerticalSlots(grid, rows, cols, verticalSlots);
    
    WordSlot wordSlots[MAX_WORDS][MAX_SLOTS];
    int slotCounts[MAX_WORDS] = {0};
    
    // Precompute valid slots for each word
    for (int i = 0; i < numWords; i++) {
        char* word = words[i];
        int len = strlen(word);
        
        // Check horizontal slots
        for (int j = 0; j < hCount; j++) {
            if (len == horizontalSlots[j].length) {
                int valid = 1;
                for (int k = 0; k < len; k++) {
                    if (grid[horizontalSlots[j].row][horizontalSlots[j].col + k] != 0 && 
                        grid[horizontalSlots[j].row][horizontalSlots[j].col + k] != word[k]) {
                        valid = 0;
                        break;
                    }
                }
                if (valid) {
                    wordSlots[i][slotCounts[i]++] = (WordSlot){'H', horizontalSlots[j].row, horizontalSlots[j].col};
                }
            }
        }
        
        // Check vertical slots
        for (int j = 0; j < vCount; j++) {
            if (len == verticalSlots[j].length) {
                int valid = 1;
                for (int k = 0; k < len; k++) {
                    if (grid[verticalSlots[j].row + k][verticalSlots[j].col] != 0 && 
                        grid[verticalSlots[j].row + k][verticalSlots[j].col] != word[k]) {
                        valid = 0;
                        break;
                    }
                }
                if (valid) {
                    wordSlots[i][slotCounts[i]++] = (WordSlot){'V', verticalSlots[j].row, verticalSlots[j].col};
                }
            }
        }
    }
    
    int used[MAX_WORDS] = {0};
    return backtrackSolution(grid, words, wordSlots, slotCounts, used, 0, numWords);
}

int main() {
    printf("[]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × m)

n! word arrangements × m valid slots per word (better pruning)

⚠ Quadratic Growth

Space Complexity

O(n × m)

Recursion stack n + precomputed slot information m

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~35 min Avg. Time

892 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

Crossword Filler - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Optimized Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler