浅谈字典树Trie
\(\;\)
本文是作者学习《算法竞赛进阶指南》的所得，有些语言是摘自其中。
\(\;\)
基础知识
定义
\(\;\)
字典树（Trie）：是一种支持字符串查询的多叉树结构。其中的每个节点，都有字符指针，指向了它的若干个儿子。
如图：
\(\;\)
空间复杂度
\(\;\)
\(O(NC)\)
其中\(N\)是节点个数，\(C\)是字符集的大小。
\(\;\)
Insert
\(\;\)
找到这个字符串在Trie中的最大前缀，把前缀后面的部分插到这个节点的后面
code
void Insert(char* str,int root)
{
int len = strlen(str);
for(int i=0;i<len;i++)
{
int c = str[i] - 'a'; //转成数字存储
if(!trie[root][c]) trie[root][c] = ++idx; //若指针为空，就新建一个指向c的指针
root = trie[root][c]; //然后继续往下遍历
}
}
Query
\(\;\)
不断地通过字符指针向下检索。直到字符指针为空，或者查询完毕为止。
code
bool Query(char* str,int root)
{
int len = strlen(str);
for(int i=0;i<len;i++)
{
int c = str[i] - 'a';
root = trie[root][c];
if(root == 0) return false; //若指针为空，则字符串不存在
}
return true;
}
Problem 1
\(\;\)
题意
\(\;\)
有\(n\)个字符串\(S_1,S_2,\cdots,S_n\)。接下来有\(M\)次询问，每次询问给定一个字符串\(T\)，求\(S_1-S_n\)有多少个字符串是\(T\)的前缀。
其中输入字符串的总长度不超过\(10^6\)
\(\;\)
做法
\(\;\)
我们把\(S_1,S_2,\cdots,S_n\)这些字符串插到一棵字典树里。(参考Insert操作)。在插入的同时，顺便在每个节点上记录一个\(cnt\)，表示多少个字符串在这里结尾。
然后对于每次询问，我们在字典树中查询这个字符串\(T\)。在查询过程中，累加上节点上\(cnt\)所得结果就是答案。
其实相当于对\(T\)的每个前缀算一下贡献。
\(\;\)
code
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1000010;
char str[N];
int n, m, tree[N][26], root, idx, end_cnt[N];
void Insert(char* str,int root)
{
int len = strlen(str);
for(int i=0;i<len;i++)
{
int c = str[i] - 'a';
if(!tree[root][c]) tree[root][c] = ++idx;
root = tree[root][c];
}
end_cnt[root] ++;
}
int Query(char* str,int root)
{
int len = strlen(str), res = 0;
for(int i=0;i<len;i++)
{
int c = str[i] - 'a';
root = tree[root][c];
if(root == 0) break;
res += end_cnt[root];
}
return res;
}
int main()
{
cin >> n >> m;
while( n-- )
{
scanf("%s",str);
Insert(str,root);
}
while( m -- )
{
scanf("%s",str);
printf("%d\n",Query(str,root));
}
return 0;
}
\(\;\)
Problem 2
\(\;\)
题意
\(\;\)
给定一颗\(n\)个节点的树，树的每条边都有一个权值。从中选择两个点\(x,y\)。使得\(x\)到\(y\)的路径上的所有边权\(xor\)(异或)起来，得到的结果最大是多少？
\(n\leq 10^5\)，边权\(\leq 2^{31}-1\)
\(\;\)
转化
\(\;\)
单看路径不太好搞，但是有一个比较套路的性质。
我们定义\(d(x)\)表示\(x\)到根节点\(root\)上边权的异或值
可以发现：对于两个点\(x\)到\(y\)路径上的异或值\(=d(x)\;xor\;d(y)\)，因为它们\(LCA\)以上的点都被异或没了（\(a\;xor\;a=0\)）。
因此我们要算的其实就是:在\(d(1),d(2),\cdots,d(n)\)中选出两个数，使得它们的异或值最大。
\(\;\)
01字典树
\(\;\)
我们可以把每个数拆分成二进制，因此，我们可以把数看作一个长度为\(31\)的\(01\)串(数值较小时在前补前导\(0\))，插到字典树中(其中最低二进制位为叶子节点)。
接下来，我们对于\(d(i)\)在\(Trie\)中进行一次与\(Query\)类似的操作。由于\(xor\)运算相同得\(0\)，不同得\(1\)的性质，每次我们都贪心往与当前位相反的指针向下访问。若与当前位相反的指针为空，则只好访问与\(d(i)\)当前位相同的指针。根据这样的贪心策略，我们可以找到最优解。
\(\;\)
code
#include <cstdio>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 100010, M = 3000010;
#define PII pair<int,int>
int n, son[M][2], root, idx, d[N], res;
vector<PII> G[N];
void Dfs(int u,int fa)
{
for(int i=0;i<G[u].size();i++)
{
int v = G[u][i].first;
if(v == fa) continue;
d[v] = G[u][i].second ^ d[u];
Dfs(v,u);
}
}
void Insert(int root,int x)
{
for(int i=30;~i;i--)
{
int s = x >> i & 1;
if(!son[root][s]) son[root][s] = ++idx;
root = son[root][s];
}
}
int Query(int root,int x)
{
int res = 0;
for(int i=30;~i;i--)
{
int s = x >> i & 1;
if(son[root][s ^ 1])
{
res += 1 << i;
root = son[root][s ^ 1];
}
else
{
root = son[root][s];
}
}
return res;
}
int main()
{
cin >> n;
for(int i=1;i<n;i++)
{
int u, v, w;
scanf("%d%d%d",&u,&v,&w);
G[u].push_back( make_pair (v, w) );
G[v].push_back( make_pair (u, w) );
}
Dfs(1,0);
for(int i=1;i<=n;i++)Insert(root, d[i]);
for(int i=1;i<=n;i++)res = max(res, Query(root, d[i]));
printf("%d",res);
return 0;
}
可持久化Trie
\(\;\)
相比于只能维护最新状态的普通的数据结构，可持久化的数据结构可以知道任意时间的历史状态。
它具体是如何实现的？
朴素想法：在每次修改后把整个数据结构\(copy\)一遍。但这样的时间、空间复杂度都是\(O(nm)\)的。(\(n\)为数据结构大小，\(m\)为版本个数)
而可持久化提供了我们一种思想：每次只记录发生变化的部分，这样时间复杂度并无增加，而空间复杂度只会增加与时间同级的规模。
例如：线段树，每次修改至多变化\(log(n)\)个节点，则空间就只会增加\(log(n)\)
下面给大家模拟一下可持久化Trie的过程。
\(\;\)
模拟过程
\(\;\)
1.设当前根节点为\(root\)，令\(p=root,idx=0\)
2.建立一个新的节点\(q\)，令\(root'=q\)
3.若\(p\)不为空，则对于每种字符\(c\)，令\(trie[q][c]=trie[p][c]\)
4.建立一个新的节点：\(trie[q][str_i]=++idx\)。
(而3，4操作其实就是除了字符\(str_i\)外，其他的信息完全相同)
5.令\(p=trie[p][str_i],q=trie[q][str_i]\)(向下遍历)
然后重复\(3-5\)的步骤，直到\(q\)到字符串末尾
图中展示了在可持久化Trie中依次插入\(cat,rat,cab,fry\)的过程。
通过这样的操作，我们就可以得到4个版本的Trie了。
\(\;\)
\(\;\)
Problem 1
\(\;\)
给定一个非负整数序列 \(a\)，初始长度为\(n\)。
有 \(m\) 个操作，有以下两种操作类型：
\(A\;\;x\)：添加操作，表示在序列末尾添加一个数 \(x\)，序列的长度加一。
\(Q\;\;l\;\;r\;\;x\)：询问操作，你需要找到一个位置 \(p\)，满足\(l\leq p\leq r\)，使得：\(a[p] \;xor \;a[p+1]\;xor\; \cdots \;xor\; a[n] \;xor\;x\) 尽可能的大，输出最大值是多少。
\(n,m\leq 3\times 10^5,a[i]\leq 10^7\)
\(\;\)
前缀和
\(\;\)
一般这种一段区间的异或和我们都用前缀和的思路来做。
令\(s_i=a[1]\;xor \;\cdots \;xor\;a[i]\)，显然\(a[l] \;xor \;a[l+1]\;xor\; \cdots \;xor\; a[r]=s_{l-1}\;xor\;s_r\)
令\(k=s_n\;xor\;x\)
也就是说：我们要找到一个\(p\;(l-1\leq p\leq r-1)，\)使得\(s_p\;xor\;k\)最大。
如果不考虑\(l-1,r-1\)的限制，那么这道题就是我们前面讲的那个\(Problem\;2\)。
但是现在有限制，如何操作?
\(\;\)
可持久化
\(\;\)
这就要用到可持久化的精髓了。既然\(p\leq r-1\)，则\(p\)一定是第\(r-1\)个版本中的\(s_i\)。
右端点处理完了，左端点？
由于我们不可以取\(<l-1\)的\(s_i\)，则我们记录一个信息\(maxid[u]\)，表示\(Trie\)中以\(u\)为根的子树中以某个二进制数为结尾的\(s_i\)的\(i\)最大是多少。
例如：以\(u\)为根的子树中，有以\(s_1,s_3,s_7\)为结尾的节点，则\(maxid[u]=7\)。
那么，在贪心找相反的指针时，如果这颗子树的\(maxid\)大于\(\geq l-1\)，说明其中至少有一个数的编号是\(\geq l-1\)的，我们就可以往其中遍历，否则只能往相同的指针方向走了。
由于插入的时候要维护\(maxid\)这个信息，所以我们采用递归的方式来写。
时间复杂度：\(O((n+m)\;log\;10^7)\)
\(\;\)
code
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 600010, M = N * 24;
int n, q, s[N], tree[M][2], root[N], idx, max_id[M];
inline int read(){
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*10+ch-'0',ch=getchar();
return s*w;
}
void Insert(int Bits, int Now, int Last, int t)
{
if(Bits < 0)
{
max_id[Now] = t;
return;
}
int v = s[t] >> Bits & 1;
if(Last) tree[Now][v ^ 1] = tree[Last][v ^ 1];
tree[Now][v] = ++idx;
Insert(Bits - 1,tree[Now][v],tree[Last][v],t);
max_id[Now] = max(max_id[tree[Now][0]],max_id[tree[Now][1]]);
}
int Query(int Now, int k, int L)
{
for(int i=23;i>=0;i--)
{
int v = k >> i & 1;
if(tree[Now][v ^ 1] && max_id[tree[Now][v ^ 1]] >= L)Now = tree[Now][v ^ 1];
else Now = tree[Now][v];
}
return k ^ s[max_id[Now]];
}
int main()
{
n = read(); q = read();
root[0] = ++idx;
Insert(23,root[0],0,0);
for(int i=1;i<=n;i++)
{
s[i] = read();
s[i] ^= s[i - 1];
root[i] = ++idx;
Insert(23, root[i], root[i-1], i);
}
while( q-- )
{
char op[2];
scanf("%s",op);
if(op[0] == 'A')
{
n ++;
s[n] = read();
s[n] ^= s[n - 1];
root[n] = ++idx;
Insert(23, root[n], root[n - 1], n);
}
else
{
int l, r, x;
l = read(); r = read(); x = read();
int t = s[n] ^ x;
printf("%d\n",Query(root[r - 1], t, l - 1));
}
}
return 0;
}
