[LeeCode 425] Word Squares

Given a set of words without duplicates, find all word squares you can build from them.

A sequence of words forms a valid word square if the kth row and column read the exact same string, where 0 ≤ k < max(numRows, numColumns).

For example, the word sequence ["ball","area","lead","lady"] forms a word square because each word reads the same both horizontally and vertically.

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

 Notice

• There are at least 1 and at most 1000 words.
• All words will have the exact same length.
• Word length is at least 1 and at most 5.
• Each word contains only lowercase English alphabet a-z.

Example

Given a set ["area","lead","wall","lady","ball"]return [["wall","area","lead","lady"],["ball","area","lead","lady"]]

Explanation:
The output consists of two word squares. The order of output does not matter (just the order of words in each word square matters).

Given a set ["abat","baba","atan","atal"]
return [["baba","abat","baba","atan"],["baba","abat","baba","atal"]]
Explanation:
The output consists of two word squares. The order of output does not matter (just the order of words in each word square matters).


Solution 1. Depth First Search
1.Enumerate one word for each row.
2. After enumerating n words(n is the length of each word), check if the square is a word square.   
If it is, add it to the final result.
3. Repeat the above steps until we've searched all possible squares.
The following code gets all possible combinations first, then check one combination. 
It causes a Memory Limit Exceeded Erroras the comb alone uses O(pow(words.length, words[0].length)) memory.

public class Solution {
    public List<List<String>> wordSquares(String[] words) {
        List<List<String>> result = new ArrayList<List<String>>();
        if(words == null || words.length == 0){
            return result;
        }
        int len = words[0].length();
        List<List<String>> comb = new ArrayList<List<String>>();
        getAllCombinations(len, words, comb, new ArrayList<String>());
        for(List<String> list : comb){
            if(isWordSquare(list)){
                result.add(list);
            }
        }
        return result;
    }
    private void getAllCombinations(int len, String[] words, List<List<String>> comb, List<String> list){
        if(list.size() == len){
            comb.add(new ArrayList<String>(list));
            return;    
        } 
        for(int i = 0; i < words.length; i++){
            list.add(words[i]);
            getAllCombinations(len, words, comb, list);
            list.remove(list.size() - 1);
        }
    }
    private boolean isWordSquare(List<String> list){
        for(int i = 0; i < list.size(); i++){
            String curr = list.get(i);
            StringBuilder sb = new StringBuilder();
            for(int j = 0; j < list.size(); j++){
                sb.append(list.get(j).charAt(i));
            }
            if(!curr.equals(sb.toString())){
                return false;
            }
        }
        return true;
    }
}


Solution 2. DFS with memory optimization
Each time we get a new combination, instead of store it, check if it is a word square "on the fly".
This optimization resolves the memory limit exceeded error. However, this algorithm is still very slow as it still needs to check all possible combinations.

public class Solution {
    public List<List<String>> wordSquares(String[] words) {
        List<List<String>> result = new ArrayList<List<String>>();
        if(words == null || words.length == 0){
            return result;
        }
        int len = words[0].length();
        getAllCombinations(len, words, result, new ArrayList<String>());
        return result;
    }
    private void getAllCombinations(int len, String[] words, List<List<String>> result, List<String> list){
        if(list.size() == len){
            if(isWordSquare(list)){
                result.add(new ArrayList<String>(list));                
            }
            return;    
        } 
        for(int i = 0; i < words.length; i++){
            list.add(words[i]);
            getAllCombinations(len, words, result, list);
            list.remove(list.size() - 1);
        }
    }
    private boolean isWordSquare(List<String> list){
        for(int i = 0; i < list.size(); i++){
            String curr = list.get(i);
            StringBuilder sb = new StringBuilder();
            for(int j = 0; j < list.size(); j++){
                sb.append(list.get(j).charAt(i));
            }
            if(!curr.equals(sb.toString())){
                return false;
            }
        }
        return true;
    }
}

 

Solution 3. DFS with Trie to avoid unecessarry work

Based on the definition of a word square, we conclude that once we fix some words on the first few rows, we can limit our search for the remaining unfilled rows to words 

that only meet certain prefix requirement.

Take the following as an example, we observe the following search criteria.

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

If "ball" fills the 1st row, then words that can fill the 2nd row must have a prefix of "a";

If "area" fills the 2nd row, then words that can fill the 3rd row must have a prefix of "le";

If "lead" fills the 3rd row, then words that can fill the 4th row must have a prefix of "lad";

 

How do we use this observation to optimize Solution 2's running time?

1. Use a Trie to store all words that have the same prefix pre.(pre will be different depending how many rows have been filled with words) 

2. Each time when searching for a word to fill the next empty row, if the next empty row must be filled with a word that has

    a prefix of pre, then we only need to search from words that have pre as prefix.

class TrieNode{
    List<String> startWith;
    TrieNode[] children;
    TrieNode(){
        this.startWith = new ArrayList<String>();
        this.children = new TrieNode[26];
    }
}

class Trie{
    TrieNode root;
    Trie(String[] words){
        this.root = new TrieNode();
        for(String s : words){
            TrieNode curr = root;
            for(char c : s.toCharArray()){
                int idx = c - 'a';
                if(curr.children[idx] == null){
                    curr.children[idx] = new TrieNode();
                }
                curr.children[idx].startWith.add(s);
                curr = curr.children[idx];
            }
        }
    }
    List<String> findByPrefix(String prefix){
        List<String> ans = new ArrayList<String>();
        TrieNode curr = root;
        for (char c : prefix.toCharArray()) {
            int idx = c - 'a';
            if (curr.children[idx] == null){
                return ans;
            }
            curr = curr.children[idx];
        }
        ans.addAll(curr.startWith);
        return ans;            
    }
}

public class Solution {
    public List<List<String>> wordSquares(String[] words) {
        List<List<String>> result = new ArrayList<List<String>>();
        if(words == null || words.length == 0){
            return result;
        }
        int len = words[0].length();
        Trie dict = new Trie(words);
        List<String> ansBuilder = new ArrayList<String>();
        for(String s : words){
            ansBuilder.add(s);
            search(len, dict, result, ansBuilder);
            ansBuilder.remove(ansBuilder.size() - 1);
        }
        return result;
    }
    private void search(int len, Trie dict, List<List<String>> result, List<String> ansBuilder){
        if(ansBuilder.size() == len){
            result.add(new ArrayList<String>(ansBuilder));
            return;
        }
        int idx = ansBuilder.size();
        StringBuilder prefixBuilder = new StringBuilder();
        for(String s : ansBuilder){
            prefixBuilder.append(s.charAt(idx));    
        }
        List<String> startWith = dict.findByPrefix(prefixBuilder.toString());
        for(String s : startWith){
            ansBuilder.add(s);
            search(len, dict, result, ansBuilder);
            ansBuilder.remove(ansBuilder.size() - 1);
        }
    }
}

 

 

 

 

Related Problems

Implement Trie 

Add and Search Word

Word Search II

Boggle Game

K Edit Distance