一本通提高篇 Trie树

前两天熬夜给班级做大合唱视频来的 所以拖了两天
那么我们今天搞这个$trie$树
不要看书上花里胡哨の一堆图 个人感觉$trie$树是个非常简洁的数奆结垢 可以考虑先看博客再看书咳咳
$UPD:$不是前两天 是前两周 累死我了 才开始写
$UPD:$复习期末考试 只有信息课有时间写…
$UPD:$$2020.3.21$重操旧业
$UPD:$复习一周期中考试…

$trie$树字典树，也叫字母树，指的是某个字符串集合对应的形如下图所示的有根树。树的每条边上加好对应一个字符，每个顶点代表从根到该点的路径所对应的字符串(将所有经过的边上的字符串按顺序连接起来)。有时我们也称$Trie$上的边为转移，顶点为状态。
顶点还能存储另外的信息，比如可以存储当前节点被遍历了几次。此外，对于任意一个节点，它到它的子节点边上的字符都互不相同。不难发现，$Trie$很好的利用了串的公共前缀，节约了储存空间

基操

这是一颗可爱的$Trie$树:

在这个$Trie$里加入的就是$at,bee,ben,bt,q$
$Trie$有三个小性质:

1. 根节点是空的，除此之外所有的节点只包含一个字符
2. 从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串
3. 每个节点的所有子节点包含的字符都不相同

都是贼**显然然后没啥用的破性质
所以对于插入或者查询每一个长度为$l$的字符串 复杂度都是$O(l)$的

那么怎么实现呢:
1.初始化
     \,\,\,\, 一颗空$Trie$树仅包含一个根节点，该点的字符指针均指向空。
2.插入
     \,\,\,\, 当需要插入一个字符串$S$时，我们令一个指针$P$起初指向根节点。然后，依次扫描$S$中的每一个字符串$c:$
$(1)$若指针$P$的$c$字符指向一个已经存在的节点$Q$，则令$P=Q$
$(2)$若指针$P$的字符指针指向空，则新建一个节点$Q$，令$P$的$c$字符指针指向$Q$，然后令$P=Q$
代码:看下面的例题
个人喜欢用结垢体 书上给的二维数组看着就丑
然后如果有需要就在这里面合理添加条件就可以了

3.查询
     \,\,\,\, 当需要查询一个字符串$S$在$Trie$中是否存在时，我们令一个指针$P$起初指向根节点，然后依次扫描$S$中的每一个字符$c:$
$(1)$若指针$P$的$c$字符指针指向空，则说明$S$没有被插过$Trie$，结束查询
$(2)$若指针$P$的$c$字符指针指向一个已经存在的节点$Q$则令$P=Q$
$(3)$当指针$S$中的字符扫描完毕时，若当前节点$P$被标记为一个字符串的末尾，则说明$S$在$Trie$中已经存在，否则说明$S$没有被插入过$Trie$

由于例题的代码不需要记录字符串末尾，所以先上例题吧:
题面
$Solution:$果题，没啥可说的，直接$Trie$

#include<bits/stdc++.h>
using namespace std;
#define reg register
struct node{
	int son[26],num;
}a[500500];
char x[55];
int n,m,t;
inline void update(){
	int l=strlen(x),p=0;
	for(reg int i=0;i<l;i++){
		if(!a[p].son[x[i]-'a'])a[p].son[x[i]-'a']=++t;
		p=a[p].son[x[i]-'a'];
	}
}
inline int query(){
	int l=strlen(x),p=0;
	for(reg int i=0;i<l;i++){
		if(!a[p].son[x[i]-'a'])return 0;
		p=a[p].son[x[i]-'a'];
	}
	return ++a[p].num;
}
int main(){
	scanf("%d",&n);
	for(reg int i=1;i<=n;i++){
		scanf("%s",x);
		update();
	}
	scanf("%d",&m);
	for(reg int i=1;i<=m;i++){
		scanf("%s",x);
		int now=query();
		if(!now)puts("WRONG");
		else if(now==1)puts("OK");
		else puts("REPEAT");
	}
}

$ok$墨迹完毕 直接上一本通题

Phone List

题面
小声$bb$一句 这题可以存字符串数组然后排序!
嘘 我们还是$Trie$吧
$Solution:$直接$Trie$就行了
如果一个串进来没有加入新的节点或者访问到了一个字符串的结尾 说明存在$A$是$B$的子串
注意两点$:1.$这是数字串 别-${}^{\prime }{a}^{\prime }$要${-}^{\prime }{0}^{\prime }$
$2.$存在输出$NO$，不存在才输出$YES...$

#include<bits/stdc++.h>
using namespace std;
#define reg register
#define N 100100
struct node{
	int pd,son[10];
}a[N];
bool now;
int n,t,cnt;
char x[15];
inline void insert(){
	int l=strlen(x),p=0,flag=0;
	for(reg int i=0;i<l;i++){
		if(!a[p].son[x[i]&15])a[p].son[x[i]&15]=++cnt,flag=1;
		p=a[p].son[x[i]&15];
		if(a[p].pd)now=1;
		if(i==l-1)a[p].pd=1;
	}
	if(!flag)now=1;
}
int main(){
	scanf("%d",&t);
	while(t--){
		memset(a,0,sizeof(a));
		cnt=now=0;
		scanf("%d",&n);
		for(reg int i=1;i<=n;i++){
			scanf("%s",x);
			insert();
		}
		if(!now)puts("YES");
		else puts("NO");
	}
}

$PS:$我杀洛谷的$UVA$慢死了 哥哥可不可以快一点呢~

The XOR Largest Pair

题目描述
给定的n个整数A1,A2,A3…An中选出两个进行异或运算，最后最大结果是多少
输入
第一行一个整数N
第二行N个整数Ai
输出
一个最大结果
样例输入
5
2 9 5 7 0
样例输出
14
提示
n<=1e5,0<=Ai<2^31
$Solution:$很容易想到把数字变成二进制放到$Trie$里
插入时最好倒序插入 这样方便统计答案
查询时先找找有没有跟这一位不一样的 如果有就跳到那里 没有就跳到跟这一位一样的 同时统计答案
下上代码↓

#include<bits/stdc++.h>
using namespace std;
#define reg register
#define N int(1e5+100)
inline void read(int &x){
	int s=0,w=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){s=(s<<3)+(s<<1)+(ch&15);ch=getchar();}
	x=s*w;
}
int n,a,ans,cnt,son[N*33][2];
inline void insert(int x){
	int now,p=0;
	for(reg int i=31;~i;i--){
		now=(x>>i)&1;
		if(!son[p][now])son[p][now]=++cnt;
		p=son[p][now];
	}
}
inline int search(int x){
	int now,p=0,ret=0;
	for(reg int i=31;~i;i--){
		now=(x>>i)&1;
		if(son[p][now^1])ret=ret<<1|1,p=son[p][now^1];
		else ret<<=1,p=son[p][now];
	}
	return ret;
}
int main(){
	read(n);
	for(reg int i=1;i<=n;i++){
		read(a);
		insert(a);
		ans=max(ans,search(a));
	}
	printf("%d\n",ans);
}

Codechef REBXOR

题目描述

输入
输入数据的第一行包含一个整数N，表示数组中的元素个数。
第二行包含N个整数A1,A2,…,AN。
输出
输出一行包含给定表达式可能的最大值。
样例输入
5
1 2 3 1 2
样例输出
6
提示
满足条件的(l1,r1,l2,r2)有：(1,2,3,3)，(1,2,4,5)，(3,3,4,5)。

对于100%的数据，2 ≤ N ≤ 4*10⁵，0 ≤ Ai ≤ 10⁹。

$Solution:$
首先我们可以想到 求$i$~$j$的异或和 就是求$1$~$j$的异或和 与 $1$~$i$的异或和的异或和
所以我们只需要维护前缀异或和 求最大区间异或和就变成了求一堆数中两个数的异或和最大 同上题
至于两个区间 那也不难 正着做一遍 反着做一遍 维护点$i$的左边和右边的区间异或和最大 最后再枚举$i$即可
上代码

#include<bits/stdc++.h>
using namespace std;
#define N 400040
#define reg register
inline void read(int &x){
	int s=0,w=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){s=(s<<3)+(s<<1)+(ch&15);ch=getchar();}
	x=s*w;
}
inline void swp(int &x, int &y){x^=y,y^=x,x^=y;}
inline int maxx(int x, int y){return x>y?x:y;}
struct node{
	int son[2];
}a[N*32];
int n,ans,cnt,num[N],s[N],le[N],ri[N];
inline void insert(int x){
	int now,p=0;
	for(reg int i=31;~i;i--){
		now=(x>>i)&1;
		if(!a[p].son[now])a[p].son[now]=++cnt;
		p=a[p].son[now];
	}
}
inline int search(int x){
	int now,p=0,ret;
	for(reg int i=31;~i;i--){
		now=(x>>i)&1;
		if(a[p].son[now^1])ret=ret<<1|1,p=a[p].son[now^1];
		else ret<<=1,p=a[p].son[now];
	}
	return ret;
}
int main(){
	read(n);
	for(reg int i=1;i<=n;i++)read(num[i]),s[i]=s[i-1]^num[i];
	for(reg int i=1;i<=n;i++){
		insert(s[i]);
		le[i]+=search(s[i]);
	}
	for(int i=1;i<=n;i++)le[i]=maxx(le[i],le[i-1]);
	memset(a,0,sizeof(a));cnt=0;
	for(reg int i=1;i<=n/2;i++)swp(num[i],num[n-i+1]);
	for(reg int i=1;i<=n;i++){
		s[i]=s[i-1]^num[i];
		insert(s[i]);
		ri[n-i+1]+=search(s[i]);
	}
	for(int i=n;i;i--)ri[i]=maxx(ri[i],ri[i+1]);
	for(reg int i=1;i<=n;i++)ans=maxx(ans,le[i]+ri[i]);
	printf("%d\n",ans);
}

Immediate Decodability

题面
$Solution:$这题跟上面第一题一样的啊 直接上代码了啊

#include<bits/stdc++.h>
using namespace std;
#define N 1001
#define reg register
struct node{
	int son[2],pd;
}a[N];
char x[N];
int ans,cnt,now;
inline void insert(){
	int l=strlen(x),p=0,flag=0;
	for(reg int i=0;i<l;i++){
		if(!a[p].son[x[i]&15])a[p].son[x[i]&15]=++cnt,flag=1;
		p=a[p].son[x[i]&15];
		if(a[p].pd)now=1;
		if(i==l-1)a[p].pd=1;
	}
	if(!flag)now=1;
}
int main(){
	while(scanf("%s",x)!=EOF){
		if(x[0]=='9'){
			if(!now)printf("Set %d is immediately decodable\n",++ans);
			else printf("Set %d is not immediately decodable\n",++ans);
			cnt=now=0;
			memset(a,0,sizeof(a));
		}
		else insert();
	}
}

L语言

题面
$Solution:$单词直接插入 标记结尾
$mark$数组代表的时这个文章哪个位置是单词的结尾
查询文章时每查到单词结尾就接着往下标记
过程中维护可以理解的$ans$的最大值

#include<bits/stdc++.h>
using namespace std;
#define reg register
#define N int(1e6+20)
struct node{
	int son[26];
	bool mk;
}a[2000];
int n,m,cnt;
bool mark[N];
char x[N];
inline void insert(){
	int l=strlen(x),p=0;
	for(reg int i=0;i<l;i++){
		if(!a[p].son[x[i]&15])a[p].son[x[i]&15]=++cnt;
		p=a[p].son[x[i]&15];
	}
	a[p].mk=1;
}
inline void find(){
	memset(mark,0,sizeof(mark));
	int ans=0,p=0,l=strlen(x);
	for(reg int i=0;i<l;i++){
		if(!a[p].son[x[i]&15])break;
		p=a[p].son[x[i]&15];
		if(a[p].mk)mark[i]=1;
	}
	for(reg int i=0;i<l;i++){
		if(!mark[i])continue;
		ans=i+1,p=0;
		for(reg int j=i+1;j<l;j++){
			if(!a[p].son[x[j]&15])break;
			p=a[p].son[x[j]&15];
			if(a[p].mk)mark[j]=1;
		}
	}
	printf("%d\n",ans);
}
int main(){
	scanf("%d%d",&n,&m);
	for(reg int i=1;i<=n;i++){
		scanf("%s",x);
		insert();
	}
	for(reg int i=1;i<=m;i++){
		scanf("%s",x);
		find();
	}
}

Secret Message 秘密信息

题面
$Solution:$这破题题面写的奇奇怪怪
总的来说就是 一个密码的答案 包含两个方面
一个是密码经过的秘密信息的结尾的数量
还有就是 是多少个秘密信息的前缀
$Trie$树上维护一个点被经过的次数 和被当做结尾的次数就好了
上代码↓

#include<bits/stdc++.h>
using namespace std;
#define N 500040
#define reg register
inline void read(int &x){
	int s=0,w=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){s=(s<<3)+(s<<1)+(ch&15);ch=getchar();}
	x=s*w;
}
struct node{
	int son[2],mk,end;
}a[N];
int n,m,k,num,cnt;
inline void insert(int k){
	int now,p=0;
	for(reg int i=0;i<k;i++){
		read(now);
		if(!a[p].son[now])a[p].son[now]=++cnt;
		p=a[p].son[now],a[p].mk++;
	}
	a[p].end++;
}
inline void search(int k){
	int now,p=0,ans=0,f=0;
	for(reg int i=0;i<k;i++){
		read(now);
		if(!a[p].son[now])f=1;
		if(f)continue;
		p=a[p].son[now],ans+=a[p].end;
	}
	if(f)printf("%d\n",ans);
	else printf("%d\n",ans-a[p].end+a[p].mk);
}
int main(){
	read(n),read(m);
	for(reg int i=1;i<=n;i++)read(k),insert(k);
	for(reg int i=1;i<=m;i++)read(k),search(k);
}

背单词

题面
$wdnmd$这啥玩意 其实我感觉我要是四五个月前正好玩图论那时候应该是能搞一搞的
这道题我是看完题解再做的
$Solution?$首先要看题面 $1$条件一定是没用的 可以避免
$2$算是$3$的特殊情况
那么这个题就转化为 一堆字符串 你可以随便排序 其中一个字符串的答案贡献值为 他前面 跟他后缀相同的字符串的距离之和
并求这个答案的最小值
看完这个后缀一定是想着把它都弄成前缀 然后用$Trie$数做
但是问题来了 怎么调整字符串的顺序才能使结果最优呢
肯定是先要建$Trie$树的 用图解释一下

要调整顺序 我们就把单词弄到树上 用单词的结尾点代表一个单词 于是单词结尾前面的信息就没用了 我们只需要记录结尾位置的信息就可以了
所以我们把所有的绿点重构成一颗树 也就是把树改成一个由单词结尾节点的树
那么怎么排呢 这里使用$dfs$序 为什么呢
这个博客里说的实在是太好了 我就搬过来吧

就是这样
上代码

#include<bits/stdc++.h>
using namespace std;
#define L 520000
#define ll long long
#define reg register
inline void read(int &x){
	int s=0,w=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){s=(s<<3)+(s<<1)+(ch&15);ch=getchar();}
	x=s*w;
}
vector<int> edge[L];
//建字典树 
struct trie{
	int son[26];
	bool tag;
}a[L];
int cnt;
char x[L];
inline void insert(){
	int l=strlen(x),p=0;
	for(reg int i=0;i<l;i++){
		if(!a[p].son[x[i]-'a'])a[p].son[x[i]-'a']=++cnt;
		p=a[p].son[x[i]-'a'];
	}
	a[p].tag=1;
}
//开始c作
//建树 
int lst[L];
void sett(int x){
	if(a[x].tag&&x)edge[lst[x]].push_back(x),lst[x]=x;
	for(reg int i=0;i<26;i++)
		if(a[x].son[i])
			lst[a[x].son[i]]=lst[x],sett(a[x].son[i]);
}
//把树重新排序 
int siz[L];
inline bool cmp(const int &x, const int &y){
	return siz[x]<siz[y];
}
void dfs(int x){
	siz[x]=1;
	for(reg int i=0;i<edge[x].size();i++){
		dfs(edge[x][i]);
		siz[x]+=siz[edge[x][i]];
	}
	sort(edge[x].begin(),edge[x].end(),cmp);
}
//按照dfs序统计答案
ll ans;
int sum;//dfn定义在外面会WA 
void getans(int x){
	int dfn=sum++;
	for(reg int i=0;i<edge[x].size();i++){
		ans+=(ll)sum-dfn;
		getans(edge[x][i]);
	}
}
int n;
int main(){
	read(n);
	for(reg int i=1;i<=n;i++){
		scanf("%s",x);
		reverse(x,x+strlen(x));
		insert();
	}
	a[0].tag=1;
	sett(0),dfs(0),getans(0);
	printf("%lld\n",ans);
}

注意:$1.$根也是绿点 不要忘了根 要不你会很惨
$2.$答案要开$longlong$
$3.$算时间戳的时候$dfn$不要定义全局变量…

The xor-longest Path

题面
这不跟前面题一样嘛…
$Solution:$设$d[x]$为$d$到根节点的异或和
对于$i$到$j$的路径的异或和$=(d[x]$^$d[lca])$ ^$(d[y]$ ^$d[lca])$
$=d[x]$^ $d[y]$ 那不就是一堆数求两个点异或最大嘛
直接上代码了

#include<bits/stdc++.h>
using namespace std;
#define N 100010
#define reg register
inline void read(int &x){
	int s=0,w=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){s=(s<<3)+(s<<1)+(ch&15);ch=getchar();}
	x=s*w;
}
struct node{
	int to,val,nxt;
}edge[N<<1];
int tot,d[N],head[N];
inline void addedge(int u, int v, int w){
	edge[++tot].to=v,edge[tot].val=w,edge[tot].nxt=head[u],head[u]=tot;
}
inline void superadd(int u, int v, int w){
	addedge(u,v,w),addedge(v,u,w);
}
void dfs(int u, int fa){
	for(reg int i=head[u];i;i=edge[i].nxt){
		int vv=edge[i].to;
		if(vv==fa)continue;
		d[vv]=d[u]^edge[i].val;
		dfs(vv,u);
	}
}
struct trie{
	int son[2];
}a[N*32];
int n,u,v,w,ans,cnt;
inline void insert(int x){
	int now,p=0;
	for(reg int i=31;~i;i--){
		now=(x>>i)&1;
		if(!a[p].son[now])a[p].son[now]=++cnt;
		p=a[p].son[now];
	}
}
inline int search(int x){
	int now,p=0,ret=0;
	for(reg int i=31;~i;i--){
		now=(x>>i)&1;
		if(a[p].son[now^1])ret=ret<<1|1,p=a[p].son[now^1];
		else ret<<=1,p=a[p].son[now];
	}
	return ret;
}
int main(){
	read(n);
	for(reg int i=1;i<n;i++)
		read(u),read(v),read(w),superadd(u,v,w);
	dfs(1,0);
	for(reg int i=1;i<=n;i++)insert(d[i]);
	for(reg int i=1;i<=n;i++)ans=max(search(d[i]),ans);
	printf("%d\n",ans);
}

$PS.$我吐了 我数组多开了个$0bz$判我$TLE$看了十分钟…
总结:$Trie$树是个解决字符串前缀问题非常好的工具 在二进制问题上也非常实用 搭配其他数据结构总能得到意想不到的效果
有问题可以留到评论区或者加$QQ407694747$ 我们一起讨论
喜欢的话可以素质三连支持一波不好意思拿错台词了
喜欢的朋友们可以给个赞哦 爱您
下一篇 $AC$自动机！