初学可持久化Trie树（字典树）

Description

　　给出n个非负整数A[1]..A[n]，编程回答询问：l r x：询问 max {x xor A[i] | l<=i<=r}的值。

Input

　　第一行为整数n。　　第二行为n个非负整数，表示A[1],A[2],…,A[n]。　　第三行为整数m。　　之后的m行，每行表示一种询问：l r x（1<=l<=r<=n）

Output

　　对于每个询问，给出你的回答。

 

学到Trie树的基本操作，便大概了解了一下可持久化Trie树。

还有很多细节没理解到位，先结合代码写一下笔记加深理解好了...如果有错误或好的理解方法还请评论指出。

对于这个题，与单个求最大异或值思想相同，贪心从最高位看对应的^能否取到。不同在于这题改为了区间求最大异或值。

我先贴出来：

#include
#include
#include
using namespace std;
typedef unsigned long long ull;
const int MAXN=500005;
const int MAXNODE=MAXN*64;
int ch[MAXNODE][2];
int root[MAXN];
int np;
ull sz[MAXNODE];

char c;
void scan(ull &x)
{
	for(c=getchar();c<'0'||c>'9';c=getchar());
	for(x=0;c>='0'&&c<='9';c=getchar()) x=x*10+c-'0';
}

char num[50];int ct;
void print(ull x)
{
	ct=0;
	if(x==0) num[ct++]='0';
	while(x) num[ct++]=x%10+'0',x/=10;
	while(ct--) putchar(num[ct]);
	putchar('\n');
}

void init()
{
	memset(sz,0,sizeof(sz));
	memset(root,0,sizeof(root));
	memset(ch,0,sizeof(ch));
	np=0;
}

void pushup(int now)
{
	sz[now]=sz[ch[now][0]]+sz[ch[now][1]];
}

void insert(int pre,int &now,int i,ull x)
{
	now=++np;//新建一个版本 
	sz[now]=sz[pre];//复制前一个版本 
	if(i<0)
	{
		sz[now]++;  //这个版本自己本身有一个元素 
		return;
	}
	int d=(x>>i)&1;
	ch[now][d^1]=ch[pre][d^1]; //d^1子树与前一个版本共用，因为当前元素不走这边 
	insert(ch[pre][d],ch[now][d],i-1,x);//d子树新建 ，当前元素走的是这边 
	pushup(now);  //更新这个节点上的值，用于后面查询判断 
}

ull ques(int l,int r,int i,ull x)
{
	if(i<0) return 0;
	int d=(x>>i)&1;
	int t=sz[ch[r][d^1]]-sz[ch[l][d^1]]; //说明r这边确实有d^1这条路（因为它比之前的版本大） 
	if(t>0) return ques(ch[l][d^1],ch[r][d^1],i-1,x)+((ull)1<>M;
	for(i=1;i<=M;i++)
	{
		scan(L);scan(R);scan(x);
		print(ques(root[L-1],root[R],63,x));//询问这个版本区间 
	}
	
	return 0;
}

 

数组大小

对于ch数组，存的是整个树的结构，最多有500000个元素，每个元素又是unsigned long long，所以每个可以分为64位，因此可能最多有500000*64个节点（与一般的二进制Tire树一样），而每个节点又可以引出0,1节点，所以二维数组ch[500005*64][2]。

sz[i]存的是从根到i节点形成的数的个数，而根据上面的，节点最多有500000*64个，所以sz[500000*64]。

root[i]存的是第i个元素从Tire树的哪一个节点开始往下走的（每一个元素的起点都是新的，也说是存Trie树的版本），元素共有500000个，所以root[500000]。

 

插入操作

传统二进制Trie树插入是这样的：

void insert(int &now,int i,ull x)
{
	if(!now) now=++np;
	if(i<0) return;
	int d=(x>>i)&1;
	insert(ch[now][d],i-1,x);
}

传统的树，确定了第i位d是0或1之后就直接往下插入。

可持续化树多出了：不断继承前一个版本的“d^1”这棵子树。因为元素x本身只用建“d”这棵子树，而“d^1”这棵子树的继承，是为了留给后面的元素如果需要就再次继承，往下建（这符合Trie树的初衷，节约空间），否则就需要额外占用空间。（也就是说，实际上ch数组没有用到那么大，但也可能卡点）

至于sz数组，记录了这个节点及其后代总共有多少个元素（节点处记录个数是基本操作），这使得每个节点都不同（因为每个节点的子树可能用到相同的子树，于是靠节点的元素个数区分），后边会用到。

void insert(int pre,int &now,int i,ull x)
{
	now=++np;       //新建一个版本（新的起点） 
	sz[now]=sz[pre];//复制前一个版本（继承） 
	if(i<0)
	{
		sz[now]++;  //这个版本自己本身有一个元素 
		return;
	}
	int d=(x>>i)&1;
	ch[now][d^1]=ch[pre][d^1];      //当前元素并用不上这棵子树，但是继承留给后边的用 
	insert(ch[pre][d],ch[now][d],i-1,x); //d子树新建 ，当前元素走的是这边
	pushup(now);        //更新这个节点上的元素个数，用于后面查询判断 
}

 

区间查询

查询时基本思路与一般的Tire树相似，从最高位开始尽可能第i位取d^1这边，若取得到便接着d^1这棵子树向下继续遍历，若取不到就走d这棵子树。

对于元素第L~R号，如果R的d^1这棵子树的大小比L的d^1子树的大小要大，说明L~R至少存在一个第i位为d^1的元素，可以继续往下走，否则就没有这样的元素，i位取不到d^1，只能走d这棵子树。

之后的步骤就跟一般的Tire树一样了。

ull ques(int l,int r,int i,ull x) //A[l]~A[r]，当前第i位，求解的元素为x 
{
	if(i<0) return 0;    //如果已经分解完 
	int d=(x>>i)&1;      
	int t=sz[ch[r][d^1]]-sz[ch[l][d^1]]; //说明r的d^1这棵子树比较大，l~r之间至少有一个i位为d^1的元素 
	if(t>0) return ques(ch[l][d^1],ch[r][d^1],i-1,x)+((ull)1<

 

小结

可持久化Tire树，关键在于每个节点对于前面的子树可继承，并且利用节点的元素个数来加以区分，（虽然不懂，但反正不管怎么说）达到了区间查询的作用。原理（虽然不懂）还是很巧妙的。