Codestin Search App

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

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
✓ Brute Force (Try All Combinations)	O(n^k * k^2)	O(k)	Generate all possible combinations and validate each square
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) — Algorithm Steps

Determine possible square sizes based on word lengths
Generate all combinations of words for each size
For each combination, check if it forms a valid word square
Validate by comparing each row with its corresponding column
Collect all valid word squares

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible combinations of words of the same length

Form Grid

Arrange each combination into a square grid

Validate Square

Check if each row equals its corresponding column

Collect Results

Store all valid word squares found

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_LEN 10

int isValidSquare(char square[][MAX_LEN], int size) {
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            if (square[i][j] != square[j][i]) {
                return 0;
            }
        }
    }
    return 1;
}

void generateCombinations(char words[][MAX_LEN], int wordCount, int size,
                         char current[][MAX_LEN], int currentSize,
                         char result[][10][MAX_LEN], int* resultCount) {
    if (currentSize == size) {
        if (isValidSquare(current, size)) {
            for (int i = 0; i < size; i++) {
                strcpy(result[*resultCount][i], current[i]);
            }
            (*resultCount)++;
        }
        return;
    }
    
    for (int i = 0; i < wordCount; i++) {
        if (strlen(words[i]) == size) {
            strcpy(current[currentSize], words[i]);
            generateCombinations(words, wordCount, size, current, currentSize + 1, result, resultCount);
        }
    }
}

int wordSquares(char words[][MAX_LEN], int wordCount, char result[][10][MAX_LEN]) {
    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]) {
            char current[10][MAX_LEN];
            generateCombinations(words, wordCount, length, current, 0, result, &resultCount);
        }
    }
    
    return resultCount;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n^k * k^2)

n^k combinations where k is square size, k^2 to validate each square

✓ Linear Growth

Space Complexity

O(k)

Space for storing current square being validated

✓ Linear Space

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