算法专练:字典树

最新推荐文章于 2023-01-31 09:23:05 发布
最新推荐文章于 2023-01-31 09:23:05 发布
阅读量231 收藏
点赞数
分类专栏： 五月集训 文章标签： 算法 c++ 数据结构 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67739923/article/details/124920179
版权

文章目录

1.1268. 搜索推荐系统

原题链接


        给你一个产品数组 products 和一个字符串 searchWord ，products 数组中每个产品都是一个字符串。

        请你设计一个推荐系统，在依次输入单词 searchWord 的每一个字母后，推荐 products 数组中前缀与 searchWord 相同的最多三个产品。如果前缀相同的可推荐产品超过三个，请按字典序返回最小的三个。

        请你以二维列表的形式，返回在输入 searchWord 每个字母后相应的推荐产品的列表。

        示例 1：

        输入：products = [“mobile”,“mouse”,“moneypot”,“monitor”,“mousepad”]
         searchWord = “mouse”

        输出：[

        [“mobile”,“moneypot”,“monitor”],

        [“mobile”,“moneypot”,“monitor”],

        [“mouse”,“mousepad”],

        [“mouse”,“mousepad”],

        [“mouse”,“mousepad”]
]

        示例 2：

        输入：products = [“havana”], searchWord = “havana”

        输出：[[“havana”],[“havana”],[“havana”],[“havana”],[“havana”],[“havana”]]

        示例 3：

        输入：products = [“bags”,“baggage”,“banner”,“box”,“cloths”], searchWord = “bags”

        输出：[[“baggage”,“bags”,“banner”],[“baggage”,“bags”,“banner”],[“baggage”,“bags”],[“bags”]]

        示例 4：

        输入：products = [“havana”], searchWord = “tatiana”

        输出：[[],[],[],[],[],[],[]]

        提示

        1 <= products.length <= 1000

        1 <= Σ products[i].length <= 2 * 10^4

        products[i] 中所有的字符都是小写英文字母。

        1 <= searchWord.length <= 1000

        searchWord 中所有字符都是小写英文字母。


        虽然这道题在对字典树比较熟悉之后没有什么难度，不过对于我来说字典树还是一个比较新的内容所以就先讲解一下了，也算是给自己记的笔记。

        这道题可以利用字典树来找出包含给定前缀的字符串，然后按照题目要求加入答案即可。我们先根据给出的product数组往字典树中插入这些字符串，然后用searchword中[0,i]（0<=i<=searchword.size()-1)这个范围为前缀去字典树中查找有这些前缀的字符串，根据题意，每个前缀要找最多三个字符串并且按照字典序升序排列，这也刚好符合字典树的构造。
        代码部分首先是字典树的数据结构:

	struct TrieNode
    {
        TrieNode* next[26];
        bool isend;
        TrieNode(){
            isend=false;
            memset(next,0,sizeof(next));
        }
    };
    //字典树的每个结点，这里是字符串字典树并且题目规定了都是小写字母，所以next结点有26个
    class Trie{
    public:
        TrieNode* root;
        Trie(){
            root=nullptr;
        }
        //插入操作：
        void insert(const string &s ){
            if(!root){
                root=new TrieNode();
            }//没有根结点先new出来一个
            TrieNode* cur=root;
            for(int i=0;i<s.size();++i){
                int idx=s[i]-'a';
                if(cur->next[idx]==nullptr){
                    cur->next[idx]=new TrieNode();
                }
                cur=cur->next[idx];
                //根据给定的字符串去看当前字典树有没有到达当前字母的路径，如果没有就new出来，最后前往这个结点。
            }
            cur->isend=true;
            //插入完成之后将当前路径标记为true代表有该路径的字符串
        }
        TrieNode* match(TrieNode* start,const string &s,int i){
            if(!start){
                return nullptr;
            }
            int idx=s[i]-'a';
            return start->next[idx];
        }
        void dfs(TrieNode* cur,vector<string>& tmp,string & prev){
            if(tmp.size()==3){
                return;
            }
            if(!cur){
                return;
            }
            if(cur->isend){
                tmp.push_back(prev);
            }
            for(int i=0;i<26;++i){
                prev.push_back(i+'a');
                dfs(cur->next[i],tmp,prev);
                prev.pop_back();
            }
        }//这里的match和dfs函数是之后查找要用到的，在这里先不解释
    };


        根据product来构建字典树：

		int i;
        Trie tree;
        for(int i=0;i<products.size();++i){
            tree.insert(products[i]);
        }


        现在我们的字典树构建完成了，之后要做的就是查找和匹配问题了：

		vector<vector<string>> ans;
        TrieNode* cur=tree.root;
        string prev="";
        for(int i=0;i<searchWord.size();++i){
            cur=tree.match(cur,searchWord,i);
            //match函数的作用是判断字典树中是否有从根结点到searchword[i]的路径，也就是有没有这个前缀
            //如果有就返回字典树中searchword[i]这个结点，如果不存在就返回空结点
            prev+=searchWord[i];//前缀
            if(!cur){
                ans.push_back({});
                //虽然如果不包含了某个前缀的话也不会有之后的前缀了，但是之后对于之后的前缀还是要加入空集合的不能直接break
            }else {
                vector<string> tmp;
                tree.dfs(cur,tmp,prev);
                ans.push_back(tmp);
                //有的话就去字典树中搜索至多三个包含当前前缀的字符串
            }
        }


        现在看我们的match和dfs函数:

	TrieNode* match(TrieNode* start,const string &s,int i){
            if(!start){
                return nullptr;
            }
            int idx=s[i]-'a';
            return start->next[idx];
            //直接返回要匹配的结点位置，这里的start是一直在移动的
            //如果之前一直都匹配的话start就是之前前缀的最后一个字母的位置，如果某次没有匹配成功会在之前直接返回空.
            //而返回的结点我们并不知道他是否存在，所以在主函数中我们进行了判断
        }
        void dfs(TrieNode* cur,vector<string>& tmp,string & prev){
            //首先是递归结束的条件，一种是tmp中加入了三个字符串，另一种是搜索到了字典树中不存在的字符串
            if(tmp.size()==3){
                return;
            }
            if(!cur){
                return;
            }
            if(cur->isend){
                tmp.push_back(prev);
            }//如果字典树中有这条路径就直接加入
            for(int i=0;i<26;++i){
                prev.push_back(i+'a');
                dfs(cur->next[i],tmp,prev);
                prev.pop_back();//遍历当前前缀的所有路径
            }
        }


        完整代码：

class Solution {
    struct TrieNode
    {
        TrieNode* next[26];
        bool isend;
        TrieNode(){
            isend=false;
            memset(next,0,sizeof(next));
        }
    };
    class Trie{
    public:
        TrieNode* root;
        Trie(){
            root=nullptr;
        }
        void insert(const string &s ){
            if(!root){
                root=new TrieNode();
            }
            TrieNode* cur=root;
            for(int i=0;i<s.size();++i){
                int idx=s[i]-'a';
                if(cur->next[idx]==nullptr){
                    cur->next[idx]=new TrieNode();
                }
                cur=cur->next[idx];
            }
            cur->isend=true;
        }
        TrieNode* match(TrieNode* start,const string &s,int i){
            if(!start){
                return nullptr;
            }
            int idx=s[i]-'a';
            return start->next[idx];
        }
        void dfs(TrieNode* cur,vector<string>& tmp,string & prev){
            if(tmp.size()==3){
                return;
            }
            if(!cur){
                return;
            }
            if(cur->isend){
                tmp.push_back(prev);
            }
            for(int i=0;i<26;++i){
                prev.push_back(i+'a');
                dfs(cur->next[i],tmp,prev);
                prev.pop_back();
            }
        }
    };
public:
    vector<vector<string>> suggestedProducts(vector<string>& products, string searchWord) {
        int i;
        Trie tree;
        for(int i=0;i<products.size();++i){
            tree.insert(products[i]);
        }
        vector<vector<string>> ans;
        TrieNode* cur=tree.root;
        string prev="";
        for(int i=0;i<searchWord.size();++i){
            cur=tree.match(cur,searchWord,i);
            prev+=searchWord[i];
            if(!cur){
                ans.push_back({});
            }else {
                vector<string> tmp;
                tree.dfs(cur,tmp,prev);
                ans.push_back(tmp);
            }
        }
        return ans;
    }
};

2.211. 添加与搜索单词 - 数据结构设计

原题链接


        请你设计一个数据结构，支持 添加新单词 和 查找字符串是否与任何先前添加的字符串匹配 。

        实现词典类 WordDictionary ：

        WordDictionary() 初始化词典对象

        void addWord(word) 将 word 添加到数据结构中，之后可以对它进行匹配

        bool search(word) 如果数据结构中存在字符串与 word 匹配，则返回 true ；否则，返回 false 。word 中可能包含一些 ‘.’ ，每个 . 都可以表示任何一个字母。

        示例：

        输入：

        [“WordDictionary”,“addWord”,“addWord”,“addWord”,“search”,“search”,“search”,“search”]

        [[],[“bad”],[“dad”],[“mad”],[“pad”],[“bad”],[“.ad”],[“b…”]]

        输出：

        [null,null,null,null,false,true,true,true]

        提示：

        1 <= word.length <= 25

        addWord 中的 word 由小写英文字母组成

        search 中的 word 由 ‘.’ 或小写英文字母组成

        最多调用 10^4 次 addWord 和 search


        这个就是单纯的字典树的查找问题了，不过由于 ‘ . ’ 的存在情况又有些特殊，对于没有 ‘. ’的字符串很简单，直接去查找即可。而当字符串在搜素到‘ . ’的时候由于他可以代表任意一个字母，这样就说明了我们可以从 a 搜素到 d ，如果在这些替代中有一个符合条件，我们直接可以返回ture。

class WordDictionary {
    struct TrieNode
    {
        TrieNode* next[26];
        bool isend;
        TrieNode(){
            isend=false;
            memset(next,0,sizeof(next));
        }
    };
    class Trie{
    public:
        TrieNode* root;
        Trie(){
            root=nullptr;
        }
        void insert(const string &s ){
            if(!root){
                root=new TrieNode();
            }
            TrieNode* cur=root;
            for(int i=0;i<s.size();++i){
                int idx=s[i]-'a';
                if(cur->next[idx]==nullptr){
                    cur->next[idx]=new TrieNode();
                }
                cur=cur->next[idx];
            }
            cur->isend=true;
        }
        bool dfs(TrieNode*  cur,const string& s,int idx){
            if(!cur){
                return false;
            }
            if(idx==s.size()){
                return cur->isend;
            }
            if(s[idx]=='.'){
                for(int i=0;i<26;++i){
                    if(dfs(cur->next[i],s,idx+1)){
                        return true;
                    }
                }
                return false;
            }else {
                return dfs(cur->next[s[idx]-'a'],s,idx+1);
            }
        }
    };
public:
    Trie t;
    WordDictionary() {
        
    }
    
    void addWord(string word) {
        t.insert(word);
    }
    
    bool search(string word) {
        return t.dfs(t.root,word,0);
    }
};

3.421. 数组中两个数的最大异或值

原题链接


        给你一个整数数组 nums ，返回 nums[i] XOR nums[j] 的最大运算结果，其中 0 ≤ i ≤ j < n 。

        示例 1：

        输入：nums = [3,10,5,25,2,8]

        输出：28

        示例 2：

        输入：nums = [0]

        输出：0

        示例 3：

        输入：nums = [2,4]

        输出：6

        示例 4：

        输入：nums = [8,10,2]

        输出：10

        示例 5：

        输入：nums = [14,70,53,83,49,91,36,80,92,51,66,70]

        输出：127

        提示：

        1 <= nums.length <= 2 * 10^4

        0 <= nums[i] <= 2^31 - 1


        这道题是经典的01字典树的运用了，01字典树就是把一个数字的二进制字符串从左往右加入到字典树中，字典树的路径只有两条，0和1就代表了这个数在该位的二进制数字为0或者1。


        我们现在的问题是异或跟字典树又有什么关系？我们考虑异或的性质，相同为0，相异为1，对于一个给定数字我们想要在字典树中找出一个与他异或结果最大的数字，现在去看给定数字的二进制字符串，从高位到低位如果想要异或结果最大，那么就尽量使得高位的二进制数字不同，也就是说对于字典树中存储的数字我们可以去找出一个与给定的数字高位二进制不同数量尽量多的一个数出来。

        而01字典树的路径之前提到过，只有0或者1，这跟异或的性质刚好吻合。这就是我们决定从高位到低位构建一个01字典树的原因。

        这里你可能又会问，题目不是要求了0<=i<=j<n吗，这样是怎么保证的？这个问题其实十分简单，我们直接把给定数组的元素一开始就全部加入到字典树中，然后从第0个开始查找到最后，由于异或具有交换律，所以对于某个 j 位置的元素，在对他进行查找的时候，在他之前的所有 i 位置的元素都已经找到了最优解了，如果他们的最优解刚好是 j 那么 j找到的最优解也会是 i 也就是他之前的元素，这种情况是不会影响结果的。而如果i 的最优解不是 j 那么j 找到的最优解也只能是 j 位置之后的元素。


        下面是代码：

class Solution {
    #define maxbit 30//根据数据范围定义一个最大bit位，这个可以是31没有影响
    struct TrieNode{
        TrieNode* next[2];//01字典树每个结点只有两个子节点
        int cnt;
        TrieNode(){
            cnt=0;
            memset(next,0,sizeof(next));
        }
    };
    class Trie{
    public:
        TrieNode* root;
        Trie(){
            root=nullptr;
        }
        void insert(int val){
            if(root==nullptr){
                root=new TrieNode();
            }
            //从高位到低位进行插入
            TrieNode* cur=root;
                for(int i=maxbit;i>=0;--i){
                int idx=((val>>i)&1);
                //将二进制中第i位的数字移到第0位并判断他是否为1
                if(!(cur->next[idx])){
                    cur->next[idx]=new TrieNode();
                }
                cur=cur->next[idx];
            }
            cur->cnt++;//这个是用来确定有多少个以当前结点为末尾的数字数目，本题中用不到
        }
        //查找与val最大异或和的数字，val是给定的数字，cur是字典树当前的结点，bit是当前寻找的bit位
        int dfs(int val,TrieNode* cur,int bit){
            if(bit==-1){
                return 0;
            }
            int idx=((val>>bit)&1)^1;
            //从高位到低位尽量找到一个与val二进制中数字不同最多的数字
            if(!cur->next[idx]){
                idx^=1;
            }//如果没有这条路径被迫去找另一条
            return (1<<bit)*idx+dfs(val,cur->next[idx],bit-1);
            //递归去找下一位与当前数字二进制位上数字不同的数字
            //其中（1<<bit)*idx是将找到数字的该位二进制数转换为十进制
        }
    };
public:
    int findMaximumXOR(vector<int>& nums) {
        Trie t;
        int i=0;
        for(i=0;i<nums.size();++i){
            t.insert(nums[i]);
        }//先插入所有nums数组中元素
        int ans=INT_MIN;
        for(i=0;i<nums.size();++i){
            ans=max(ans,t.dfs(nums[i],t.root,maxbit)^nums[i]);
        }//去对nums数组中每个元素查找他的最大异或和并求出他们的最大值
        return ans;
    }
};

4.1707. 与数组中元素的最大异或值

原题链接


        给你一个由非负整数组成的数组 nums 。另有一个查询数组 queries ，其中 queries[i] = [xi, mi] 。

        第 i 个查询的答案是 xi 和任何 nums 数组中不超过 mi 的元素按位异或（XOR）得到的最大值。换句话说，答案是 max(nums[j] XOR xi) ，其中所有 j 均满足 nums[j] <= mi 。如果 nums 中的所有元素都大于 mi，最终答案就是 -1 。

        返回一个整数数组 answer 作为查询的答案，其中 answer.length == queries.length 且 answer[i] 是第 i 个查询的答案。

        示例 1：

        输入：nums = [0,1,2,3,4], queries = [[3,1],[1,3],[5,6]]

        输出：[3,3,7]

        示例 2：

        输入：nums = [5,2,4,6,6,3], queries = [[12,4],[8,1],[6,3]]

        输出：[15,-1,5]

        提示：

        1 <= nums.length, queries.length <= 10^5

        queries[i].length == 2

        0 <= nums[j], xi, mi <= 10^9


        读完题后，我们首先确定这道题肯定还是利用01字典树来对每次询问进行查找。可以有了mi的限制就使得本题麻烦了很多，因为在查找的时候要时刻考虑m的存在，试想一下对于每次dfs不管是我们先去去确定路径，还是确定当前路径是否比m大，在不合法的时候我们都要进行回溯，在数据量小的时候这样做当然可以，但是观察数据0<=m<=10^9 ,0<= queries.length<=10^5这样做肯定会t的。

        现在我们的主要问题就是m，能不能找到一种方法在查找中不考虑m的存在呢？答案是可以的，我们把queries按照m来进行从小到达排序，并且在排序queries的每个元素后面加入一个元素作为他们在答案数组中的原始下标。同样的nums也从小到大来进行排序，这样做是为了消除m在查找过程中的影响。

        现在我们把插入和搜素放在同一个过程中进行，先定义一个遍历numsidx代表当前nums数组我们到达的位置，对于每个queries的操作我们先记录下他的xi，mi，以及我们加入的原始下标ri。在进行查找之前先进行插入操作，当numsidx没有越界，也就是没有超过nums的元素数量，并且nums[numsudx]<=mi的情况下对nums[numsjdx]进行插入，直到这两个条件有一个不满足。这样由于我们对于询问是按照mi的升序排列，并且nums也是按照升序排列的。所以字典树中每次在进行查找的时候都是不大于mi的元素，这样就把mi的影响消除了，剩下的就是01字典树的查找问题了。这种先考虑输入数据再看原始数据的方法真的很妙。

class Solution {
    #define maxbit 29//依然是根据题目数据自定义的最大比特位，31当然也没有影响
    struct TrieNode{
        TrieNode* next[2];
        int cnt;
        TrieNode(){
            memset(next,0,sizeof(next));
            cnt=0;
        }
    };
    class Trie{
    public:
        TrieNode* root;
        Trie(){
            root=nullptr;
        }
        void insert(int val){
            if(!root){
                root=new TrieNode();
            }
            TrieNode* cur=root;
            for(int i=maxbit;i>=0;--i){
                int idx=(val>>i)&1;
                if(!cur->next[idx]){
                    cur->next[idx]=new TrieNode();
                }
                cur=cur->next[idx];
            }
            cur->cnt++;
        }
        int dfs(int val,TrieNode* cur,int bit){
            if(bit==-1){
                return 0;
            }
            int idx=(val>>bit)&1^1;
            if(!cur->next[idx]){
                idx^=1;
            }
            return (1<<bit)*idx+dfs(val,cur->next[idx],bit-1);
        }//从这里可以看出01字典树没有任何改变，只是我们的解题思路发生了变化
    };
public:
    vector<int> maximizeXor(vector<int>& nums, vector<vector<int>>& queries) {
        int i;
        vector<int> ans;
        Trie t;
        sort(nums.begin(),nums.end());//对nums进行排序
        for(i=0;i<queries.size();++i){
            queries[i].push_back(i);
            ans.push_back(-1);
        }//对queries加入他在答案数组中的原始下标，ans也象征性的加入一些元素方便索引
        sort(queries.begin(),queries.end(),[&](vector<int>& a,vector<int>&b){
            return a[1]<b[1];
        }
        );//根据mi进行升序排列
        int numsidx=0;
        for(i=0;i<queries.size();++i){
            int xi=queries[i][0];
            int mi=queries[i][1];
            int ri=queries[i][2];
            while(numsidx<nums.size()&&nums[numsidx]<=mi){
                t.insert(nums[numsidx]);
                ++numsidx;
            }//nums不越界并且当前元素小于mi的情况下，字典树中插入nums[numsidx]
            if(numsidx){
                ans[ri]=t.dfs(xi,t.root,maxbit)^xi;
            }//如果numsidx不是0就代表者字典树中存在元素可以开始查找了
        }
        return ans;//最后返回答案数组
    }
};
爱吃烤秋刀鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 字典树详解(含例题)
jerry20183的博客
02-03 4317
C++ 字典树详解(含例题) 字典树的定义 顾名思义，就是一个像字典一样的树，谢谢观看 我们想要熟练的运用字典树，首先肯定要知道什么样的结构才会被称之为字典树吧。 字典树是一种树形结构，典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较———百度百科 从上面的百度百科的一段定义中，我们知道了字典树是：利用字符串的公共前缀来减少复杂度；用于统计，排序和保存大量字符串的数据结构
字典树（trie）题库+详解
mapleaf的博客
07-24 959
字典树 #include <bits/stdc++.h> using namespace std; const int maxn=1e6+10; int sum[maxn]={0}; int trie[maxn][26]; char s[15]; int pos=1; void add() //插入 { int c=0; for(int i=0;s[i];i++) ...
[ 字典树题目 ]
Acer12138的博客
09-06 336
Problem Description Ignatius最近遇到一个难题,老师交给他很多单词(只有小写字母组成,不会有重复的单词出现),现在老师要他统计出以某个字符串为前缀的单词数量(单词本身也是自己的前缀). Input 输入数据的第一部分是一张单词表,每行一个单词,单词的长度不超过10,它们代表的是老师交给Ignatius统计的单词,一个空行代表单词表的结束.第二部分是一连串的提问,...
【算法题】1268. 搜索推荐系统
最新发布
kangbin825的专栏
01-31 432
输出：[[“baggage”,“bags”,“banner”],[“baggage”,“bags”,“banner”],[“baggage”,“bags”],[“bags”]]输入：products = [“mobile”,“mouse”,“moneypot”,“monitor”,“mousepad”], searchWord = “mouse”输出：[[“havana”],[“havana”],[“havana”],[“havana”],[“havana”],[“havana”]]
LeetCode刷题 --字典树
qq_43325216的博客
11-11 267
Trie是一种树型的数据结构，用于检索字符串数据集中的键。Trie树是一个有根的树，主要思想是用字符串的共用前缀来节约存储空间。
ACM-字符串处理专练
01-13
3. **字符串匹配**：涉及到模式匹配问题，比如正则表达式匹配，Trie树（字典树）或Aho-Corasick自动机常用于快速查找多个模式。 4. **字符串反转**：这是一个常见的字符串操作，可以使用双指针技术或者栈来实现。 ...
algz:用于训练和娱乐的算法和数据结构
07-10
数据结构方面，"algz"涵盖了数组、链表、栈、队列、树（二叉树、平衡树如AVL树和红黑树）、图、哈希表等基础类型，以及更高级的数据结构如堆、字典树、B树等。这些数据结构的设计和操作直接影响到程序的运行效率和...
详细的机器学习算法项目
05-29
1. **Python编程基础**：作为机器学习的主要编程语言，Python的基础语法、数据结构（如列表、字典、集合、元组）和控制流程（循环、条件语句）是必不可少的。此外，了解如何使用Numpy、Pandas等库进行数据处理也非常...
常用的小算法-小问题的集成
10-25
6. **图论算法**：如Dijkstra算法求最短路径、Floyd算法解决所有顶点间的最短路径、Kruskal和Prim算法构建最小生成树等，这些都是解决网络问题的重要工具。 7. **字符串处理**：KMP算法、Rabin-Karp算法和Boyer-...
北大算法ACM
12-19
2. **数据结构**：线性结构（数组、链表、栈、队列）、树形结构（二叉树、平衡树如AVL和红黑树）、图结构以及特殊数据结构如哈希表、字典树（Trie）等，这些都是算法实现的基础。 3. **数学基础**：离散数学、图论...
简述字典树
Nxin的小抄本
08-27 1325
字典树主要用于字符串的存储与查询，其与哈希存储相比，具有近乎相同的时间效率和较高的空间效率，关键是字典树能完成一些用哈希很难解决又有较高时间要求的问题。假设给定我们一些小写英文字符构成的字符串，要求给一个前缀，能快速返回这组单词中拥有该前缀的数量，比如“brad”，“bread”，“bed”，“bedroom”，“bedding”这五个字符串。快速查找最好的办法就是用哈希了，时间复杂度为O(1)。但是查找具有相同前缀单词的数量，这个用哈希似乎并不能很好解决，下面我们看下字典树是如何处理的。如果没有定义val
CF1446:Xor Tree(字典树好题)
Jay_fc的博客
05-08 165
题目链接 #include <bits/stdc++.h> using namespace std; const int maxn=2e5+5; int a[maxn]; int n,idx; int son[maxn*35][2]; int f[maxn*35]; void insert(int x){ int p=0; for(int i=31;i>=0;i--){ int t=(x>>i)&1; if(!s.
【原创】字典树的五种实现方式
suvedo的博客
11-04 1398
字典树（trie树），是一种前缀树，可以在O(m)的时间复杂度匹配目标字符串（m为目标字符串的长度），字典树广泛应用在NLP领域作为词典，具体应用有：分词、词频统计、字符串查询、字符串排序等。 虽然字典树有较低的时间复杂度，但当词典较大时（如中文分词词典），字典树占用的空间非常大，常常难以满足工业应用的需求，因此需要在保持字典树优异的时间复杂度的前提下，尽可能的优化字典树的空间。本文由浅入深，讲解经典字典树、链表字典树、Hash表字典树、双数组字典树、单数组字典树5种字典树实现及各种实现的优缺点。 经典字典
算法--字典树
大魔王
07-06 306
字典树主要用于大量具有相同前缀的字符串存储与检索。字符串的前缀匹配 字典树数据结构： 对于每一个节点，都有一个叶子节点数组，如果字符串都是小写字母，一般叶子节点数组为26，利用字符的索引来快速定位叶子节点数组位置。常见的基本操作 插入 查找 前缀查找： 插入：每遍历字符串中的一个字母，若该字母没有出现过，则就在对应的空位置往下生成一个 TrieTrie；若该字母出现过，则直接继续遍历下一个字母，直到字符串遍历结束（注意：结束时要标记为 endend，表示这个单词已经结束了）。 查找：遍历要...
字典树的题目 找了个时间刷了一点字典树的题目
sdut_jean的博客
04-26 1225
http://acm.sdut.edu.cn/onlinejudge2/index.php/Home/Contest/contestproblem/cid/2009/pid/2828 #include #include #include #include #include using namespace std; struct node { int v; node
Leetcode刷题：字典树 类型题目总结
九九六.爱吸油
03-17 833
词典中最长的单词 给出一个字符串数组 words 组成的一本英语词典。返回 words 中最长的一个单词，该单词是由 words 词典中其他单词逐步添加一个字母组成。 若其中有多个可行的答案，则返回答案中字典序最小的单词。若无答案，则返回空字符串。 原文链接： https://leetcode-cn.com/problems/longest-word-in-dictionary/ 解题思路 涉及到前缀，便考虑使用字典树结构用于存储相同前缀的内容，当然本题也可以用hash表进行存储 遍历每个字符串，若前缀
字典树专题
wangheng
07-31 3261
字典树   又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。 它有3个基本性质： 根节点不包含字符，除根节点外每一个节点都只包含一个字符。从根节点到某一
统计难题（字典树模板题）
康康康康的博客
07-29 1462
题意：     Ignatius最近遇到一个难题,老师交给他很多单词(只有小写字母组成,不会有重复的单词出现),现在老师要他统计出以某个字符串为前缀的单词数量(单词本身也是自己的前缀)，这个题意还是很好理解的，输入方面稍微有一点点坑，但是习惯就好 = = 判断读入的是不是一串空得字符串，可以用gets()函数去实现，可以通过读入的字符串是不是为空判断。 链接：    HDU 1251传送门 ...
HDU1298 非常好的题 字典树+DFS
Start_to_crazy的博客
01-24 435
题意： 模拟手机打字的猜想功能，根据概率，每按一个按键，输出可能性最高的串。先给定N个单词，以及频率，就是每个单词中字母的频率，比如：“hell，3”和“hello ，4”，则前缀相同时，h的频率为4+3=7。 题解： https://www.cnblogs.com/A-way/archive/2012/11/22/2783176.html 这是我这道题看的博客。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值