Trie学习总结

Trie树学习总结

字典树,又称前缀树,是用于快速处理字符串的问题,能做到快速查找到一些字符串上的信息。

另外,Trie树在实现高效的同时,会损耗更多的空间,所以Trie是一种以空间换时间的算法。

Trie的思想

Trie的思想十分简单,其实我在很早之前就已经懂了Trie的思想,只不过一直没有实现,所以就……

咕咕,没事,Trie无论是思想还是代码思想都还是很简单。现在我重新再搞回Trie也很快就代码实现了。

Trie是思想其实用图更容易展现。下面放一张图给大家看看,相信大家很快就会明白了。

如果我们插入字符串:

zlh
AK
tql
AKIOI
AKnoip


上面就是一颗我们建的Trie树。

如果我们要查找“zlh”,那么就会沿着1->2->3点找下去。

如果我们要查找“AKIOI”,那么我们就会沿着4->5->9->10->11点找

也可以十分容易发现"AK"是"AKIOI"的前缀。

那么大家现在应该就能明白Trie的构造了吧。

简单说就是顺着之前Trie树的构造去插入点,例如我们最后插入"AKnoip",就会先走过"A"和"K",然后发现没有匹配的字符了,就先后新建了'n','o','i','p',这几个点。复杂度O(len(字符串))。

查询就会沿着Trie的构造一个一个跳,所以查询复杂度是O(len(字符串))。

那么Trie的思想就是这样了。

Trie的实现

明白了思想,实现就应该很简单了吧,这里通过一道例题来实现Trie。

题目:P2580 于是他错误的点名开始了

定义

struct kkk{
    int son[27],cnt;
    bool flag;
}trie[maxn];

首先是插入操作:

void insert(string s){
    int len=s.size(),u=0;		//获取长度len,u是当前点的编号,根的编号是0
    for(int i=0;i<len;i++){
        int v=s[i]-'a';		//获取位置
        if(!trie[u].son[v])	//如果没有继续下去的节点
        trie[u].son[v]=++num;	//就新建一个
        u=trie[u].son[v];	//跳到下一个点去插入
    }
    trie[u].flag=true;	//标记此处是一个单词
}

然后是查询操作:

int find(string s){
    int len=s.size(),u=0;
    for(int i=0;i<len;i++){
        int v=s[i]-'a';		//同上
        if(!trie[u].son[v])return 3;	//找不到返回没有
        u=trie[u].son[v];	//同上
    }
    if(trie[u].flag==false)return 3;	//不是一个单词就返回没有
    if(!trie[u].cnt){		//如果没有被点过
        trie[u].cnt++;		//标记被点过了
        return 1;			//返回有
    } return 2;			//不然返回重复
}

那么Trie的实现就这样了。

Trie的考点

  1. 异或XOR以及利用XOR的性质
  2. 后缀转前缀
  3. 记忆化,缩点,重构树,Trie的思想(见 P3294 [SCOI2016]背单词,P2292 [HNOI2004]L语言
  4. 可持久化(详见下文

随便给点题

phone list

The XOR Largest Pair

Nikitosh 和异或

Immediate Decodability

[SCOI2016]背单词

[HNOI2004]L语言

[USACO08DEC]秘密消息Secret Message

最长异或路径

做完上面那几道应该就能了解Trie

习题讲解

1、phone list

题目:Phone list

题目意思十分明确,求有没有一个字符串是其他字符串的前缀,如果有就返回"NO",没有返回"YES"。

这题和前面讲的Trie的作用一模一样,可以快速判断一个字符串是不是已插入的字符串中的前缀。

那么这道题就很简单了,我们先将全部字符串都插入到Trie中。

然后查找每一个字符串,如果字符串下有儿子,那么就代表当前字符串是某个字符串的前缀,直接返回。

代码实现也很简单,可以算是Trie的模板题。

#include<bits/stdc++.h>
using namespace std;
struct kkk{
    int son[11],sum;
    bool flag;
    void clear(){memset(son,0,sizeof(son));sum=0;flag=0;}   //清0
}trie[400001];
int n,T,num;
string S[400001];
void insert(string s){
    int len=s.size(),u=0;
    for(int i=0;i<len;i++){
        int v=s[i]-'0';
        if(!trie[u].son[v])
        trie[u].son[v]=++num;
        trie[u].sum++;          //表示u有多少个儿子
        u=trie[u].son[v];
    }
    trie[u].flag=true;
}
int find(string s){
    int len=s.size(),u=0;
    for(int i=0;i<len;i++){
        int v=s[i]-'0';
        if(!trie[u].son[v])return 0;        //找不到字符串就返回
        u=trie[u].son[v];
    }
    if(trie[u].sum==0)return 0; //如果没有儿子就代表不是前缀
    return 1;           //否则就是前缀
}
int main(){
    scanf("%d",&T);
    while(T--){
        num=0;      //记得清0
        for(int i=0;i<=400000;i++)trie[i].clear();  //记得清0
        scanf("%d",&n);
        for(int i=1;i<=n;i++){
            cin>>S[i];
            insert(S[i]);       //一个一个插入
        }
        bool ans=false;
        for(int i=1;i<=n;i++){
            int res=find(S[i]); //查询
            if(res==1){ans=true;break;} //判断是不是前缀
        }
        if(ans==true)printf("NO\n");    //输出
        else printf("YES\n");
    }
}

2、Immediate Decodability

题目:Immediate Decodability

这道题和上面那道题一模一样,不过输入比较恶心,而且数据范围也比较小。

这里的输入就是不断输入字符串S,然后将字符串S插入到Trie中,直到S='9'为止。

到了S='9',就将之前的S都像上面的一样查询一边,输出答案,然后清0。

代码:

#include<bits/stdc++.h>
using namespace std;
struct kkk{
    int son[11],sum;
    bool flag;
    void clear(){memset(son,0,sizeof(son));sum=0;flag=0;}
}trie[2001];
int n,T,num,t;
string S[400001];
void insert(string s){
    int len=s.size(),u=0;
    for(int i=0;i<len;i++){
        int v=s[i]-'0';
        if(!trie[u].son[v])
        trie[u].son[v]=++num;
        trie[u].sum++;
        u=trie[u].son[v];
    }
    trie[u].flag=true;
}
int find(string s){
    int len=s.size(),u=0;
    for(int i=0;i<len;i++){
        int v=s[i]-'0';
        if(!trie[u].son[v])return 0;
        u=trie[u].son[v];
    }
    if(trie[u].sum==0)return 0;
    return 1;
}
void solve(){               //解决之前的字符串
    bool ans=false;
    for(int i=1;i<=n;i++){
        int res=find(S[i]);
        if(res==1){ans=true;break;}
    }
    if(ans==true)printf("Set %d is not immediately decodable\n",t);
    else printf("Set %d is immediately decodable\n",t);
}
int main(){n=1;
    while(cin>>S[n]){
        if(S[n]=="9"){
            t++;
            solve();            //解决之前的问题
            memset(trie,0,sizeof(trie));    //清0
            num=0;n=1;continue; //清0
        }
        insert(S[n]);n++;       //如果不是‘9’就插入
    }
}

3、The XOR Largest Pair

题目:The XOR Largest Pair

这道题是一道变向的Trie,也是Trie的一个基本应用。

思路:

1、首先将a[i]转换为二进制的字符串存起来,记得空位要补0

2、然后将这些字符串都插入到Trie里。

3、查询每一个字符串,找到以每一个数和另外其他数的最大异或和。

那么问题就是怎么找一个数和另外其他数的最大异或和了。

我们知道,异或是不同就为1,相同就为0,所以我们因尽量让高位的二进制为1。

所以我们查询的时候就倒着查,也就是如果s[i]为0,那么我们就查1。但是没有1怎么办,我们总不能就此放弃吧,于是我们继续查0。

最后取个最大值就OK了。

看看代码:

#include<bits/stdc++.h>
using namespace std;
struct kkk{
    int son[3],sum;
    bool flag;
    void clear(){memset(son,0,sizeof(son));sum=0;flag=0;}
}trie[4000001];
int n,T,num,ans;
int x[1000001];
void insert(string s){          //插入
    int len=s.size(),u=0;
    for(int i=0;i<len;i++){
        int v=s[i]-'0';
        if(!trie[u].son[v])
        trie[u].son[v]=++num;
        trie[u].sum++;
        u=trie[u].son[v];
    }
    trie[u].flag=true;
}
int find(string s){
    int len=s.size(),u=0,ans=0,num=(int)(2147483648ll/2ll);
    for(int i=0;i<len;i++){
        int v=((s[i]-'0')^1);       //倒着查
        if(!trie[u].son[v])v^=1;    //找不到就倒回来
        else ans+=num;              //不然就累加进去
        u=trie[u].son[v];num/=2;    //跳下一个
    }
    return ans;
}
string decompose(int x){            //拆分成二进制
    string s="";
    while(x!=0)
    s+=(x%2)+'0',x>>=1;
    while(s.size()!=31)s+='0';
    reverse(s.begin(),s.end());
    return s;       //返回字符串
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&x[i]);
        string s=decompose(x[i]);
        insert(s);
    }
    for(int i=1;i<=n;i++){
        int res=find(decompose(x[i]));
        ans=max(ans,res);           //取最大值
    }
    printf("%d\n",ans);
}

4、[USACO08DEC]秘密消息Secret Message

题目大意:给你n个信息和m个密码,要你求出对于每一个密码都多少信息,使这些信息的前缀和密码的前缀相同。

理解清题目,这道题就很简单了,我们用信息来在建立Trie时多维护一个数据sum,存的是有多少个信息经过这个节点。那么我们在查询时,先统计有多少信息是密码的前缀再加上当前节点的sum就是答案。

#include<bits/stdc++.h>
using namespace std;
struct kkk{
    int son[11],sum,flag;
    void clear(){memset(son,0,sizeof(son));sum=0;flag=0;}
}trie[400001];
int n,T,num,ans;
string S[400001];
void insert(string s){
    int len=s.size(),u=0;
    for(int i=0;i<len;i++){
        int v=s[i]-'0';
        if(!trie[u].son[v])
        trie[u].son[v]=++num;
        u=trie[u].son[v];trie[u].sum++;	//记录sum
    }
    trie[u].flag++;		//有重复所以要加加
}
int find(string s){
    int len=s.size(),u=0,ans=0;
    for(int i=0;i<len;i++){
        int v=s[i]-'0';
        if(!trie[u].son[v])return ans;	//找不到
        u=trie[u].son[v];
        ans+=trie[u].flag;		//记录信息是密码前缀
    }
    return ans-trie[u].flag+trie[u].sum;	//-trie[u].flag是为了去重
}
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        int x;
        scanf("%d",&x);string s="";char c;
        for(int j=1;j<=x;j++)cin>>c,s+=c;
        insert(s);
    }
    for(int i=1;i<=m;i++){
        int x;
        scanf("%d",&x);string s="";char c;
        for(int j=1;j<=x;j++)cin>>c,s+=c;
        ans=find(s);
        printf("%d\n",ans);
    }
}

5、Nikitosh 和异或

题目在这里:「一本通 2.3 例 3」Nikitosh 和异或

首先对于如何求异或最大值我们已经在上文学到了,现在我们要求的是两个没有覆盖的区间异或的和。

异或有一个性质:就是据有可减性,也就是说我们记前缀异或sum数组,如果求[l,r]的异或和,那么答案就是sum[r]^sum[l-1];后缀异或也是一样的

所以我们可以对于每一个位置i都求一遍以i为结尾的区间中,最大的区间异或值。方法是将i前面的每一个前缀sum数组都插入到Trie中,然后find(sum[i]),答案计为l数组

另外,对于每一个位置i都求一遍以i为开头的区间中,最大的区间异或值。方法是将i后面的每一个后缀sum数组都插入到Trie中,然后find(sum[i]),答案计为r数组

那么对于每一个位置i,都统计前面的最大的l,记录下来。表示的是i前面的最大区间异或和

对于每一个位置i,都统计后面的最大的r,记录下来。表示的是i后面的最大区间异或和

那么答案就是对于每一个位置i的 前面的最大区间异或和 和 后面的最大区间异或和 的 和 的最大值

代码:

#include<bits/stdc++.h>
using namespace std;
struct kkk{
    int son[3];
    void clear(){memset(son,0,sizeof(son));}
}trie[8000001];
int n,T,num,ans;
int x[1000001],l[1000001],r[1000001],s[35];
void insert(int x){
    int j=-1,u=0;
    memset(s,0,sizeof(s));
    while(x){
        s[++j]=x&1;
        x>>=1;
    }
    for(int i=31;i>=0;i--){
        if(!trie[u].son[s[i]])
        trie[u].son[s[i]]=++num;
        u=trie[u].son[s[i]];
    }
}
int find(int x){
    int ans=0,u=0;
    for(int i=31;i>=0;i--){
        int v=1-s[i];
        if(!trie[u].son[v])v^=1;
        else ans+=(1<<i);
        u=trie[u].son[v];
    }
    return ans;
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&x[i]);
    }
    int sumx=0;num=0;
    for(int i=1;i<=n;i++)
        sumx^=x[i],insert(sumx),
        l[i]=max(l[i-1],find(sumx));
    memset(trie,0,num+1);
    sumx=0;num=0;
    for(int i=n;i>=1;i--)
        sumx^=x[i],
        insert(sumx),
        r[i]=max(r[i+1],find(sumx));
    for(int i=1;i<n;i++)ans=max(ans,l[i]+r[i+1]);
    printf("%d\n",ans);
}

可持久化Trie

posted @ 2019-04-10 16:44  Hastieyua  阅读(647)  评论(1编辑  收藏  举报