Leetcode 425. Word Squares

Problem:

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 k^th 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

Note:

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

Example 1:

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

Output:
[
  [ "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).

Example 2:

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

Output:
[
  [ "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:

　　又是道恐怖的Trie的题目，这道题首先需要创建Trie数据结构，里面有个函数getStartsWith(TrieNode *r)是用DFS的方法获取所有从节点r开始的后缀。下面用Example1说明算法思路，path初始化为长宽均为4的字符串数组，首先遍历所有字符串先放满第一行和第一列，比如：

　　["wall",

　　 "a   ",

　　 "l   ",

　　 "l   "]

然后开始放第二行和第二列，此时我们需要用getStartsWith(TrieNode *r)函数获取前缀为a的所有后缀组合，并一个个尝试，其中一个结果为：

　　["wall",

　　 "area",

　　 "le   ",

　　 "la   "]

然后对于第三行和第三列找到前缀为le的所有后缀组合，以此类推，直到index为5即可。

Code:

 

struct TrieNode{
    TrieNode *next[26];
    bool isEnd;
    TrieNode():isEnd(false){
        for(int i = 0;i != 26;++i)
            next[i] = NULL;
    }
};
class Trie{
public:
    Trie(){
        root = new TrieNode();
    }
    void insert(string &word){
        TrieNode *current = root;
        for(int i = 0;i != word.size();++i){
            if(current->next[word[i]-'a'] == NULL){
                current->next[word[i]-'a'] = new TrieNode();
            }
            current = current->next[word[i]-'a'];
        }
        current->isEnd = true;
    }
    void dfs(TrieNode *r,string path,vector<string> &result){
        if(r->isEnd){
            result.push_back(path);
            return;
        }
        for(int i = 0;i != 26;++i){
            if(r->next[i] != NULL){
                dfs(r->next[i],path+(char)(i+'a'),result);
            }
        }
    }
    vector<string> getStartsWith(TrieNode *r) {
        vector<string> result;
        dfs(r,"",result);
        return result;
    }
    TrieNode *getRoot(){
        return root;
    }
private:
    TrieNode *root;
};
class Solution {
public:
    void backtrace(int index,Trie &tree,TrieNode *root,vector<string> &path,vector<vector<string>> &result){
        int m = path.size();
        if(index == m){
            result.push_back(path);
            return;
        }
        TrieNode *current = root;
        for(int i = 0;i != index;++i){
            if(current->next[path[index][i]-'a'] == NULL)
                return;
            current = current->next[path[index][i]-'a'];
        }
        vector<string> suffix = tree.getStartsWith(current);
        for(int i = 0;i != suffix.size();++i){
            for(int j = index;j != m;++j){
                path[index][j] = suffix[i][j-index];
                path[j][index] = suffix[i][j-index];
            }
            backtrace(index+1,tree,root,path,result);
            for(int j = index;j != m;++j){
                path[index][j] = ' ';
                path[j][index] = ' ';
            }
        }
    }
    vector<vector<string>> wordSquares(vector<string>& words) {
        Trie tree;
        for(int i = 0;i != words.size();++i)
            tree.insert(words[i]);
        TrieNode *root = tree.getRoot();
        int m = words[0].size();
        vector<vector<string>> result;
        vector<string> path(m,string(m,' '));
        for(int i = 0;i != words.size();++i){
            for(int j = 0;j != m;++j){
                path[0][j] = words[i][j];
                path[j][0] = words[i][j];
            }
            backtrace(1,tree,root,path,result);
            for(int j = 0;j != m;++j){
                path[0][j] = ' ';
                path[j][0] = ' ';
            }
        }
        return result;
    }
};