Word Squares - Practice Coding Problems

Word Squares - Problem

Imagine you're creating a word crossword puzzle where words read the same both horizontally and vertically! Given an array of unique strings words, you need to find all possible word squares you can build.

A word square is a sequence of strings where the k^th row and k^th column read exactly the same string. Think of it as a perfect symmetric grid where grid[i][j] == grid[j][i] for all positions.

Example: The words ["ball", "area", "lead", "lady"] form a valid word square:

b a l l
a r e a
l e a d
l a d y

Notice how column 0 reads "ball" (same as row 0), column 1 reads "area" (same as row 1), and so on!

Goal: Return all possible word squares you can construct. The same word can be used multiple times, and order doesn't matter.

Input & Output

example_1.py — Basic Word Square

$ Input: ["area", "lead", "wall", "lady", "ball"]

› Output: [["ball", "area", "lead", "lady"]]

💡 Note: Only one valid word square can be formed: 'ball', 'area', 'lead', 'lady'. Notice how each row reads the same as its corresponding column.

example_2.py — Multiple Solutions

$ Input: ["abat", "baba", "atan", "atal"]

› Output: [["baba", "abat", "baba", "atan"], ["baba", "abat", "baba", "atal"]]

💡 Note: Two valid word squares exist with these words. The word 'baba' can be used multiple times to create different valid arrangements.

example_3.py — No Solution

$ Input: ["abc", "def", "ghi"]

› Output: []

💡 Note: No valid word square can be formed because none of these words can satisfy the constraint that row[i] must equal column[i].

Time & Space Complexity

Time Complexity

⏱️

O(n * k^k)

n words, k^k possible squares of size k, but heavy pruning reduces actual complexity

✓ Linear Growth

Space Complexity

O(n * k + k^2)

Prefix map storage plus recursion stack and current square

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 4
All words[i] have the same length
words[i] consists of only lowercase English letters
All the strings of words are unique

Asked in

The optimal approach uses backtracking with Trie optimization. Build a Trie from all words, then use backtracking to construct word squares row by row. For each position, the Trie helps quickly find valid words that match the required prefix from the corresponding column. This dramatically reduces the search space compared to brute force, achieving O(n * k^k) complexity with heavy pruning.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking with Prefix Matching	O(n * k^k)	O(n * k + k^2)	Use backtracking with early termination based on prefix constraints
Brute Force (Try All Combinations)	O(n^k * k^2)	O(k)	Generate all possible combinations and validate each square

Backtracking with Prefix Matching — Algorithm Steps

Build a prefix map: group words by their prefixes
Start with an empty square and use backtracking
For each row, determine the required prefix from the current column
Only consider words that match the required prefix
If no valid words exist for a prefix, backtrack immediately
When square is complete, add to results

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Prefix Map

Create a mapping from prefixes to words that start with those prefixes

Start Backtracking

Begin with first word and recursively add rows

Check Constraints

For each new row, ensure it matches column prefix requirements

Prune Early

If no word matches required prefix, backtrack immediately

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_LEN 10
#define MAX_RESULTS 1000

typedef struct {
    char prefix[MAX_LEN];
    char words[MAX_WORDS][MAX_LEN];
    int count;
} PrefixEntry;

PrefixEntry prefixMap[MAX_WORDS * MAX_LEN];
int prefixCount = 0;

int findPrefixIndex(const char* prefix) {
    for (int i = 0; i < prefixCount; i++) {
        if (strcmp(prefixMap[i].prefix, prefix) == 0) {
            return i;
        }
    }
    return -1;
}

void addToPrefix(const char* prefix, const char* word) {
    int index = findPrefixIndex(prefix);
    if (index == -1) {
        strcpy(prefixMap[prefixCount].prefix, prefix);
        strcpy(prefixMap[prefixCount].words[0], word);
        prefixMap[prefixCount].count = 1;
        prefixCount++;
    } else {
        strcpy(prefixMap[index].words[prefixMap[index].count], word);
        prefixMap[index].count++;
    }
}

void buildPrefixMap(char words[][MAX_LEN], int wordCount) {
    for (int i = 0; i < wordCount; i++) {
        char prefix[MAX_LEN];
        for (int j = 0; j <= strlen(words[i]); j++) {
            strncpy(prefix, words[i], j);
            prefix[j] = '\0';
            addToPrefix(prefix, words[i]);
        }
    }
}

int backtrack(char square[][MAX_LEN], int row, int length,
              char results[][10][MAX_LEN], int* resultCount) {
    if (row == length) {
        for (int i = 0; i < length; i++) {
            strcpy(results[*resultCount][i], square[i]);
        }
        (*resultCount)++;
        return 1;
    }
    
    char prefix[MAX_LEN];
    prefix[0] = '\0';
    
    for (int i = 0; i < row; i++) {
        char temp[2] = {square[i][row], '\0'};
        strcat(prefix, temp);
    }
    
    int prefixIndex = findPrefixIndex(prefix);
    if (prefixIndex == -1) return 0;
    
    int found = 0;
    for (int i = 0; i < prefixMap[prefixIndex].count; i++) {
        char* word = prefixMap[prefixIndex].words[i];
        if (strlen(word) == length) {
            int valid = 1;
            
            for (int j = row + 1; j < length && valid; j++) {
                char colPrefix[MAX_LEN];
                colPrefix[0] = '\0';
                
                for (int k = 0; k < row; k++) {
                    char temp[2] = {square[k][j], '\0'};
                    strcat(colPrefix, temp);
                }
                char temp[2] = {word[j], '\0'};
                strcat(colPrefix, temp);
                
                if (findPrefixIndex(colPrefix) == -1) {
                    valid = 0;
                }
            }
            
            if (valid) {
                strcpy(square[row], word);
                found += backtrack(square, row + 1, length, results, resultCount);
            }
        }
    }
    
    return found;
}

int wordSquares(char words[][MAX_LEN], int wordCount, char results[][10][MAX_LEN]) {
    buildPrefixMap(words, wordCount);
    
    int resultCount = 0;
    int wordLengths[MAX_LEN] = {0};
    
    for (int i = 0; i < wordCount; i++) {
        wordLengths[strlen(words[i])] = 1;
    }
    
    for (int length = 1; length < MAX_LEN; length++) {
        if (wordLengths[length]) {
            for (int i = 0; i < wordCount; i++) {
                if (strlen(words[i]) == length) {
                    char square[10][MAX_LEN];
                    strcpy(square[0], words[i]);
                    backtrack(square, 1, length, results, &resultCount);
                }
            }
        }
    }
    
    return resultCount;
}

int main() {
    char words[][MAX_LEN] = {"area", "lead", "wall", "lady", "ball"};
    int wordCount = 5;
    char results[MAX_RESULTS][10][MAX_LEN];
    
    int count = wordSquares(words, wordCount, results);
    
    printf("[");
    for (int i = 0; i < count; i++) {
        printf("[");
        int length = strlen(results[i][0]);
        for (int j = 0; j < length; j++) {
            printf("\"%s\"", results[i][j]);
            if (j < length - 1) printf(",");
        }
        printf("]");
        if (i < count - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * k^k)

n words, k^k possible squares of size k, but heavy pruning reduces actual complexity

✓ Linear Growth

Space Complexity

O(n * k + k^2)

Prefix map storage plus recursion stack and current square

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 4
All words[i] have the same length
words[i] consists of only lowercase English letters
All the strings of words are unique

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Backtracking with Prefix Matching — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler