【暖*墟】 #trie# 字典树的运用

Trie,又称字典树

是一种用于实现字符串快速检索的多叉树结构。

每个节点都拥有若干个字符指针,若在插入或检索字符串时扫描到一个字符c ,

就沿着当前节点的c这个字符指针,走向该指针指的节点。

下面我们来详细讨论Trie的基本操作过程。

初始化

一棵空Trie仅包含一个根节点,该点的字符指针均指向空。

*********  根节点表示空串。*********

插入

当需要插入一个字符串S时,我们令一个指针P起初指向根节点。

然后,依次扫描S中的每个字符c。

1.若P的c字符指针指向一个已经存在的节点Q,则令P=Q。

2.若P的c字符指针指向空,则新建一个节点Q,令P的c字符指针指向Q,然后令P=Q。

当S中的字符扫描完毕时,在当前节点P上标记它是一个字符串的末尾。

检索

当需要检索一个字符串S在Trie中是否存在时,我们令一个指针P起初指向根节点,

然后依次扫描S中的每个字符c:

1.若P的c字符指针指向空,则说明S没有被插入过Trie,结束检索。

2.若P的的c字符指针指向一个已经存在的节点Q,则令P=Q。

当S中的字符扫描完毕时,若当前节点P被标记为一个字符串的末尾,

则说明S在Trie中存在,否则说明S没有被插入过Trie。

即先将字符传入字典树中，查询的时候从根节点向下层寻找（每层26个字母）。

任意一个线结点所表示的字符串，都是实际字符串集合中某些串的前缀。

——> 利用串的公共前缀，节约空间。可以看做26叉树（全是小写英文字母）。

    bool tail[SIZE]; //串尾元素
    int trie[SIZE][26],tot=1; //SIZE:字符串最大长度（层数）
    //tot为节点编号,用它可以在trie数组中表示某层的某字母是否存在

    void insert(char* str){ //插入一个字符串
    int len=strlen(str),p=1; //p初始化为根节点
    for(int k=0;k<len;k++){
    int ch=str[k]-‘a‘; //小写字符组成串的某个字符，变成数字
    if(trie[p][ch]==0) trie[p][ch]=++tot; //trie存编号tot
    //↑↑↑不存在此层的这个字符，新建结点，转移边
    p=trie[p][ch]; //指针移动，连接下一个位置
    }
    tail[p]=true; //s中字符扫描完毕，p标记的是字符串的末位字符（的编号）
    }

    bool searchs(char* str){ //检索字符串是否存在
    int len=strlen(str),p=1; //p初始化为根节点
    for(int k=0;k<len;k++){
    p=trie[p][str[k]-‘a‘]; //寻找下一处字符
    //trie[lastp][ch1]=nowp;
    //trie[nowp][ch2]=nextp;
    //nowp=trie[nowp][ch2]=nextp; 即寻找下一处字符的编号
    if(p==0) return false; //某层字符没有编号，不存在，即串也不存在
    }
    return tail[p]; //判断最后一个字符
    }

字典树trie 例题

（1）【电话簿】 poj 3630

#include <cmath>
#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;

/*【电话簿】 poj 3630
多组数据，每组n个长度不超过10的数字串，
问是否存在数字串S,T。使得S是T的前缀。  */

//构建Trie,过程中可以顺便判断答案

const int maxn=1e5+9;
int trie[maxn][10]; //数字只有0~9
int n,tot,T;
bool tail[maxn];
char s[20]; //每个串长度不超过10

void clears(){ //初始化清零
    memset(trie,0,sizeof(trie));
    memset(tail,false,sizeof(tail));
}

bool insert(char* s){ //插入一个字符串T,判断S是不是它的前缀
    int len=strlen(s),p=1; //p初始化为根节点
    bool flag=false;
    for(int k=0;k<len;k++){
        int ch=s[k]-‘0‘; //小写字符组成串的某个字符，变成数字
        if(trie[p][ch]==0) trie[p][ch]=++tot; //trie存编号tot
        //↑↑↑不存在此层的这个字符，新建结点，转移边
        else if(k==len-1) flag=true; //没有插入任何新节点
        p=trie[p][ch]; //指针移动，连接下一个位置
        if(tail[p]) flag=true; //经过某个有标记的结点，即完成了某个串
    }
    tail[p]=true; //s中字符插入完毕，p标记的是字符串的末位字符（的编号）
    return flag;
}

int main(){
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n); tot=1; //tot是编号数
        clears(); bool ans=false;
        for(int i=1;i<=n;i++){
            scanf("%s",s);
            if(insert(s)) ans=true;
        }
        if(ans) puts("YES");
        else puts("NO");
    }
    return 0;
}

（2）【按位异或】 bzoj 4260

#include <cmath>
#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;

/*【按位异或】 bzoj 4260 */

/*【分析】设l[i]表示1<=l<=r<=i的最大a[l]^a[l+1]^...^a[r],
r[i]表示i<=l<=r<=n的最大a[l]^a[l+1]^...^a[r],
则结果为最大的l[i]+r[i+1]。问题转化为求l[i]和r[i]。
设x[i]表示a[0]^a[1]^...^a[i]（a[0]=0），那么l[i]=max(x[i]^x[j])(j<i) */

/*【求一组数中两个数 异或 得到的最大值】
把每个整数看成长度为31的二进制01串（在前面补0），
并把31位的串插进一棵trie树（最低二进制位为叶节点），
进行类似查找的过程：沿着“与当前位相反的字符指针”向下层访问。
如果“与ai当前位相反的字符指针”指向空节点，就访问ai当前位指针。
根据xor运算“相同=0，不同=1”，求出异或值最大的ai和aj。 */

const int maxn=4e5+9;
int trie[maxn<<5][2]; //数字只有0~9
int n,tot=1,l[maxn],r[maxn],a[maxn];

void clears(){ //初始化清零
    memset(trie,0,sizeof(trie));
}

void insert(int x){ //插入一个二进制数
//将当前的前/后缀异或和化为31位二进制数，插入trie树
    int p=1; //p初始化为根节点
    for(int i=1<<30;i;i>>=1){ //每次除二
        int c=(x&i)? 1:0;
        if(trie[p][c]==0) trie[p][c]=++tot; //trie存编号tot
        //↑↑↑不存在此层的这个字符，新建结点，转移边
        p=trie[p][c]; //指针移动，连接下一个位置
    }
}

int finds(int x){ //找目前最大的两数异或和
    int p=1,ans=0;
    for(int i=1<<30;i;i>>=1){ //从高位到低位，尽量让异或和高位为1
        int c=(x&i)? 0:1; //每一位反过来
        if(trie[p][c]){ //这一位记录过，可以继续
            ans+=i; p=trie[p][c]; //查询与相反相连的下一位
        }
        else p=trie[p][!c]; //否则这一位只能为0，连接与相同相连的下一位
    }
    return ans;
}

int main(){
    int now,ans=0;
    scanf("%d",&n); insert(now=0); //存a[0]的异或值

    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        now^=a[i]; //now为a[0]~a[i]的异或和
        insert(now);
        l[i]=max(l[i-1],finds(now));
        //l[i]表示1<=l<=r<=i的最大a[l]^a[l+1]^...^a[r]
    }

    clears(); tot=1; insert(now=0); //重新初始化
    for(int i=n;i>=1;i--){
        now^=a[i]; //now为a[n]~a[i]的异或和
        insert(now);
        r[i]=max(r[i+1],finds(now));
        //r[i]表示i<=l<=r<=n的最大a[l]^a[l+1]^...^a[r]
    }

    for(int i=1;i<n;i++)
        ans=max(ans,l[i]+r[i+1]);
    printf("%d\n",ans);
    return 0;
}

（3）【IMMEDIATE DECODABILITY】poj 1056

#include <cmath>
#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;

/*【IMMEDIATE DECODABILITY】poj 1056
给你一些字符串,每组数据以9结尾,判断给出的字符串中,
是否存在一个字符串是另外一个字符串的前缀(如:01为010的前缀);
如果存在至少一组这种情况输出：Set %d is not immediately decodable ;
不存在则输出：Set %d is immediately decodable 。 */

//构建Trie,过程中可以顺便判断答案

const int maxn=1e5+9;
int trie[maxn][10]; //数字只有0~9
int tot=1;
bool tail[maxn];
char s[20]; //每个串长度不超过10

void clears(){ //初始化清零
    memset(trie,0,sizeof(trie));
    memset(tail,false,sizeof(tail));
}

bool insert(char* s){ //插入一个字符串T,判断S是不是它的前缀
    int len=strlen(s),p=1; //p初始化为根节点
    bool flag=false;
    for(int k=0;k<len;k++){
        int ch=s[k]-‘0‘; //小写字符组成串的某个字符，变成数字
        if(trie[p][ch]==0) trie[p][ch]=++tot; //trie存编号tot
        //↑↑↑不存在此层的这个字符，新建结点，转移边
        else if(k==len-1) flag=true; //没有插入任何新节点
        p=trie[p][ch]; //指针移动，连接下一个位置
        if(tail[p]) flag=true; //经过某个有标记的结点，即完成了某个串
    }
    tail[p]=true; //s中字符插入完毕，p标记的是字符串的末位字符（的编号）
    return flag;
}

int main(){
    int kase=1,flag=0;
    while(scanf("%s",s)!=EOF){
        if(s[0]==‘9‘){
            if(!flag) printf("Set %d is immediately decodable\n",kase++);
            else printf("Set %d is not immediately decodable\n",kase++);
            flag=0; tot=1; clears(); continue;
        }
        if(!flag&&insert(s)) flag=1;
    }
    return 0;
}

（4）【L语言】bzoj 1212

#include <cmath>
#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;

/*【bzoj 1212】L语言
标点符号的出现晚于文字的出现，所以以前的语言都是没有标点的。
现在你要处理的就是一段没有标点的文章。一段文章T是由若干小写字母构成。
一个单词W也是由若干小写字母构成。一个字典D是若干个单词的集合。
我们称一段文章T在某个字典D下是可以被理解的，是指如果文章T可以被分成若干部分，
且每一个部分都是字典D中的单词。 例如字典D中包括单词{‘is’, ‘name’, ‘what’, ‘your’}，
则文章‘whatisyourname’是在字典D下可以被理解的,因为它可以分成4个单词：‘what’, ‘is’, ‘your’, ‘name’，
且每个单词都属于字典D，而文章‘whatisyouname’ 在字典D下不能被理解，
但可以在字典D’=D+{‘you’}下被理解。这段文章的一个前缀‘whatis’，
也可以在字典D下被理解 而且是在字典D下能够被理解的最长的前缀。
给定一个字典D，你的程序需要判断若干段文章在字典D下是否能够被理解。
并给出其在字典D下能够被理解的最长前缀的位置。  */

//【分析】令f[i]表示到i的前缀能否被理解，那么答案就是f[i]==1时最大的i。
// 如果f[i]==1，这个串就可以从i+1开始匹配一个新单词，设trie上匹配到一个长度为j的单词,那么f[i+j]=1。

const int maxn=(1<<20)+10;
int n,m,len,f[maxn];
char s[maxn];

struct trie{
    int tot,ch[2010][26];bool ok[maxn];
    void insert(){
        int p=0,len=strlen(s);
        for(int i=0;i<len;p=ch[p][s[i]-‘a‘],i++)
            if(!ch[p][s[i]-‘a‘]) ch[p][s[i]-‘a‘]=++tot;
        ok[p]=1; //队尾标记
    }
}T;

int work(int t){
    int ans=0; len=strlen(s+1);
    f[0]=t;
    for(int i=0;i<=len;i++){
        if(f[i]!=t) continue;
        else ans=i;
        for(int p=0,j=i+1;j<=len;j++){
            p=T.ch[p][s[j]-‘a‘];
            if (!p) break;
            if (T.ok[p]) f[j]=t;
        }
    }
    return ans;
}

int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        scanf("%s",s),T.insert();
    for(int i=1;i<=m;i++)
        scanf("%s",s+1),printf("%d\n",work(i));
    return 0;
}

（5）bzoj 1590 / bzoj 4567 / bzoj 1954

——时间划过风的轨迹，那个少年，还在等你。

原文地址：https://www.cnblogs.com/FloraLOVERyuuji/p/9346737.html

时间： 2024-11-08 02:45:34

【暖*墟】 #trie# 字典树的运用的相关文章

DFA和trie字典树实现敏感词过滤（python和c语言）

现在做的项目都是用python开发,需要用做关键词检查,过滤关键词,之前用c语言做过这样的事情,用字典树,蛮高效的,内存小,检查快. 到了python上,第一想法是在pip上找一个基于c语言的python字典树模块,可惜没找到合适的,如果我会用c写python模块的话,我就自己写一个了,可惜我还不具备这个能力, 只能用python写了,性能差一点就差点吧,内存多一点也无所谓了. 用搜索引擎看CSDN上的网友的用python实现的DFA,再参照自己以前用c语言写过的字典树,有些不大对,就自己写了一

Trie 字典树 删除操作

字典树的删除操作: 1 没找到直接返回 2 找到叶子节点的时候,叶子节点的count标志清零,代表不是叶子节点了 3 如果当前节点没有其他孩子节点的时候,可以删除这个节点 判断是否需是叶子节点,就检查叶子节点的count标志就可以了. 判断是否有其他孩子节点就需要循环26个节点了,如果都为空,那么就没有其他孩子节点了. #include <stdio.h> #include <stdlib.h> #include <iostream> #include <vect

Trie字典树 动态内存

Trie字典树 1 #include "stdio.h" 2 #include "iostream" 3 #include "malloc.h" 4 #include "string.h" 5 6 using namespace std; 7 8 #define MAX_SIZE 26 9 10 typedef struct Trie{ 11 char val; 12 bool isword; 13 struct Trie*

萌新笔记——C++里创建 Trie字典树（中文词典）（插入、查找、遍历、导入、导出）（上）

写了一个词典,用到了Trie字典树. 写这个词典的目的,一个是为了压缩一些数据,另一个是为了尝试搜索提示,就像在谷歌搜索的时候,打出某个关键字,会提示一串可能要搜索的东西. 首先放上最终的结果: input: 1 编程入门 2 编程软件 3 编程学习 4 编程学习网站 output: 1 char : 件 2 word : 编程软件 3 char : 习 4 word : 编程学习 5 char : 网 6 word : 编程学习网 7 char : 门 8 word : 编程入门 其实这里不应

算法导论：Trie字典树

1. 概述 Trie树,又称字典树,单词查找树或者前缀树,是一种用于快速检索的多叉树结构,如英文字母的字典树是一个26叉树,数字的字典树是一个10叉树. Trie一词来自retrieve,发音为/tri:/ “tree”,也有人读为/tra?/ “try”. Trie树可以利用字符串的公共前缀来节约存储空间.如下图所示,该trie树用10个节点保存了6个字符串pool.prize.preview.prepare.produce.progress 在该trie树中,字符串preview,prepa

trie/字典树几题

以后有好多次看到这地方就过去了, 未亲自实践过. 不过今晚看了一下,感觉trie的思想还算是比较基础的. 感觉这一个链接讲的不错:http://www.cnblogs.com/BeyondAnyTime/archive/2012/07/16/2592838.html 顺便水了几道题. 具体列表可见:http://vjudge.net/contest/view.action?cid=47036#overview A:水题啦. 稍微理解下trie就能写出来了. 附个自己写的代码,还是用LRJ书上的非

【oiClass1502】查单词（Trie字典树）

题目描述 全国英语四级考试就这样如期来了,可是小y依然没有做好充分准备.为了能够大学毕业,可怜的小y决定作弊.小y费尽心机,在考试的时候夹带了一本字典进考场,但是现在的问题是,考试的时候可能有很多的单词要查,小y能不能来得及呢? 输入 第一行一个整数N,表示字典中一共有多少个单词(N<=10000).接下来每两行表示一个单词,其中:第一行是一个长度<=100的字符串,表示这个单词,全部小写字母,单词不会重复.第二行是一个整数,表示这个单词在字典中的页码.接下来是一个整数M,表示要查的单词数(M

LeetCode 208.实现Trie(字典树) - JavaScript

??Blog :<LeetCode 208.实现Trie(字典树) - JavaScript> 实现一个 Trie (前缀树),包含 insert, search, 和 startsWith 这三个操作. Trie trie = new Trie(); trie.insert("apple"); trie.search("apple"); // 返回 true trie.search("app"); // 返回 false trie.

Trie 字典树

1.UVa 1401 Remember the Word 题意:给出n个字符串集合,问其有多少种组合方式形成目标字符串. 思路:对n个字符串集合建立Trie树,保存每个结点的字符串的顺序编号.然后对这棵树查找目标字符串每一个后缀的前缀字符串,累加. 1 #include<cstdio> 2 #include<cstring> 3 #include<algorithm> 4 #include<iostream> 5 #include<vector>