算法刷题(c/c++)---字典树

1. 题源：leetcode 每日一题2022.7.7

2. 描述：

在英语中，我们有一个叫做 词根(root) 的概念，可以词根后面添加其他一些词组成另一个较长的单词——我们称这个词为 继承词(successor)。例如，词根an，跟随着单词 other(其他)，可以形成新的单词 another(另一个)。

现在，给定一个由许多词根组成的词典 dictionary 和一个用空格分隔单词形成的句子 sentence。你需要将句子中的所有继承词用词根替换掉。如果继承词有许多可以形成它的词根，则用最短的词根替换它。

你需要输出替换之后的句子。

示例 1：

输入：dictionary = [“cat”,“bat”,“rat”], sentence = “the cattle was rattled by the battery”
输出：“the cat was rat by the bat”
示例 2：

输入：dictionary = [“a”,“b”,“c”], sentence = “aadsfasf absbs bbab cadsfafs”
输出：“a a b c”

提示：

1 <= dictionary.length <= 1000
1 <= dictionary[i].length <= 100
dictionary[i] 仅由小写字母组成。
1 <= sentence.length <= 10^6
sentence 仅由小写字母和空格组成。
sentence 中单词的总量在范围 [1, 1000] 内。
sentence 中每个单词的长度在范围 [1, 1000] 内。
sentence 中单词之间由一个空格隔开。
sentence 没有前导或尾随空格。

3. 思路分析

1.将字符串按空格分割成若干字符串
2.对分割的字符进行判断,如果和前缀匹配上则替换为前缀

4. 代码部分

class Solution {
public:
    string replaceWords(vector<string>&dictionary , string sentence) {
        string result="";
        int j=0;
        //分割字符串
        for(int i=0;i<sentence.size();i++){
            if(sentence[i]==' '||i==sentence.size()-1){
                if(i!=sentence.size()-1){
                    result+=replace(sentence.substr(j,i-j),dictionary);
                    result+=" ";
                }
                else{
                    result+=replace(sentence.substr(j,i+1-j),dictionary);
                }
                j=i+1;
            }
        }
    return result;
    }
    //对分割的若干字符换进行替换
    string replace(string a,vector<string>& dictionary){
    //当alt  altt都满足时，要记得取最短的alt
        int k=INT_MAX;
        string temp=a;
        for(int i=0;i<dictionary.size();i++){
            if(temp.find(dictionary[i])==0&&dictionary[i].size()<=k){
                a=dictionary[i];
                k=a.size();
            }
        }
    
        return a;
    }
};

5. 用字典树优化

上述代码实现出来时间复杂度太高，主要是判断字符子串和前缀是否存在匹配时用的是暴力法，这里其实有更好的匹配方法—字典树

5.1 字典树

字典树（前缀树）是一种特殊的多叉树，其结点设计与多叉树有所不同 。
其树结点如下：

struct Trie {
    bool isEnd;
	Trie *next[26];
} ;

Trie的结点结构中没有直接使用一个成员来保存结点值。而是使用字母映射表next，数组中保存了对当前结点而言下一个可能出现的字符
按照这种理解，我们可以完成字典树的以下几个操作

5.2 字典树的创建

struct Trie {
    bool isEnd;
	Trie *next[26];
} ;

Trie* creatTrie() {
    Trie *node=new Trie;
    for (int i = 0; i < 26; i++) {
        node->next[i] =nullptr;
    }
    node->isEnd = false;
    return node;
}

5.3 字典树的插入

void insert(string word,Trie* root) {
	Trie *p=root;
	for(auto i:word){
		if(p->next[i-'a']==nullptr){
			p->next[i-'a']=new Trie();
		}
		p=p->next[i-'a'];
	}
	p->isEnd=true;
}

5.3 字典树的其他操作

**理解了增加，也很容易理解删除和查找**

5.4优化后的代码为

class Solution {
public:
    //定义结构体
    struct Trie {
        bool isEnd;
	    Trie *next[26];
    } ;
    //节点创建
    Trie* creatTrie() {
        Trie *node=new Trie;
        for (int i = 0; i < 26; i++) {
            node->next[i] =nullptr;
        }
        node->isEnd = false;
        return node;
    }
    //插入操作
    void insert(string word,Trie* root) {
	    Trie *p=root;
	    for(auto i:word){
		    if(p->next[i-'a']==nullptr){
			    p->next[i-'a']=new Trie();
		    }
		    p=p->next[i-'a'];
	    }
	    p->isEnd=true;
     }
    
    string replaceWords(vector<string>&dictionary , string sentence) {
        string result="";
        int j=0;
        Trie * root=creatTrie();
        for( auto i:dictionary){
            insert(i,root);
        }

        //分割字符串
        for(int i=0;i<sentence.size();i++){
            if(sentence[i]==' '||i==sentence.size()-1){
                if(i!=sentence.size()-1){
                    result+=replace(sentence.substr(j,i-j),root);
                    result+=" ";
                }
                else{
                    result+=replace(sentence.substr(j,i+1-j),root);
                }
                j=i+1;
            }
        }
    return result;
    }
    //字典树的查找
    string replace(string a,Trie *root){
        Trie *p=root;
        string b="";
        for(auto i:a){
            if(p->next[i-'a']!=nullptr){           
                b.push_back(i);
                p=p->next[i-'a'];
                if(p->isEnd==true)  return b;
            }
            else return a;
        }          
    return a;
    }
};

5.4优化前后对比