leetcode 648. Replace Words

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:

1. The input will only have lower-case letters.
2. 1 <= dict words number <= 1000 
3. 1 <= sentence words number <= 1000 
4. 1 <= root length <= 100 
5. 1 <= sentence words length <= 1000 

class TrieNode{
public:
    char var;
    bool isWord;
    TrieNode* children[26];
    
    TrieNode()   
    {    
        var = 0;    
        isWord = false;    
        memset(children, 0, sizeof(TreeNode*)*26);    
    
    }    
    TrieNode(char c)  
    {    
        var = c;    
        isWord = false;    
        memset(children, 0, sizeof(TreeNode*)*26);    
    }    
};

class Solution {
public:
    string replaceWords(vector<string>& dict, string sentence) 
    {
        root = new TrieNode();
        //构造字典树
        for (auto s : dict)
        {
            TrieNode* p = root;
            for (int k = 0; k < s.size(); k++)
            {
                if (p->children[s[k] - 'a'] == 0)
                {
                    TrieNode* pnew = new TrieNode(s[k]);
                    p->children[s[k] - 'a'] = pnew;
                }
                p = p->children[s[k] - 'a'];
            }
            p->isWord = true;
        }
        
        vector<string> sen = helper(sentence);
        for (int i = 0; i < sen.size(); i++)
        {
            TrieNode* p = root;
            string s = sen[i];
            for (int k = 0; k < s.size(); k++)
            {
                if (p->isWord)
                {
                    sen[i] = sen[i].substr(0, k);
                    break;
                }
                if (p->children[s[k] - 'a'] == 0)
                {
                    break;
                }
                p = p->children[s[k] - 'a'];
            }
        }
        
        return helper2(sen);
    }
private:
    TrieNode* root;
    vector<string> helper(string s)
    {
        vector<string> ret;
        int start = 0;
        int k = 0;
        while (start < s.size())
        {
            while (k < s.size() && s[k] != ' ')
                k++;
            ret.push_back(s.substr(start, k - start));
            start = (++k);
        }
        return ret;
    }
    
    string helper2(vector<string> s)
    {
        string ret = "";
        for (auto ss : s)
            ret = ret + " " + ss;
        return ret.substr(1);
    }
};