Leetcode--648. Replace Words

题目

In English, we have a concept called root, which can be followed by some other words to form another longer word - let’s call this word successor. For example, the root an, followed by other, which can form another word another.

Now, given a dictionary consisting of many roots and a sentence. You need to replace all the successor in the sentence with the root forming it. If a successor has many roots can form it, replace it with the root with the shortest length.

You need to output the sentence after the replacement.

Example 1:
Input: dict = [“cat”, “bat”, “rat”]
sentence = “the cattle was rattled by the battery”
Output: “the cat was rat by the bat”
Note:
The input will only have lower-case letters.
1 <= dict words number <= 1000
1 <= sentence words number <= 1000
1 <= root length <= 100
1 <= sentence words length <= 1000

思路

Trie，根据字典构建字典树，然后对sentence分词，逐个比较，最后拼接成结果字符串，返回

代码

typedef struct Trie_node   {
    bool exist; /// 标记该结点处是否构成单词
    struct Trie_node* next[26]; /// 指向各个子树的指针
    Trie_node() : exist(false) {
        memset(next, 0, sizeof(Trie_node*)*26);
    }
} TrieNode, *Trie;

class Solution {
public:
    string replaceWords(vector<string>& dict, string sentence) {
        string res;
        if(sentence.length() == 0)
            return res;

        Trie root = new TrieNode();
        buildTrie(root, dict);

        stringstream ss(sentence);
        string temp;
        ss >> temp;
        res += findStr(root, temp);
        while(ss >> temp)
            res += " " + findStr(root, temp);
        return res;
    }

    void buildTrie(Trie root, const vector<string>& dict) {
        int index;
        for(int j=0; j<dict.size(); ++j) {
            Trie p = root;
            int i = 0;
            for(; i<dict[j].length(); ++i) {
                index = dict[j][i]-'a';
                if(p->next[index] == NULL)
                    p->next[index] = new TrieNode();
                p = p->next[index];
                if(i == dict[j].length()-1)
                    p->exist = true;
            }
        }
    }

    string findStr(Trie root, const string& str) {
        Trie p = root;
        int index;
        for(int i=0; i<str.length(); ++i) {
            index = str[i]-'a';
            if(p->next[index]) {
                if(p->next[index]->exist)
                    return str.substr(0, i+1);
                p = p->next[index];
            } else
                return str;
        }
        return str;
    }
};