可持久化trie树
可持久化trie树现在想来是比较好理解的了，但却看了一个下午...
相当于对于每个状态建立一条链（或者说一棵trie），求解的时候只要让两个点按照相同的步子走然后看sum的大小关系即可。
tr[y].son[p xor 1]:=tr[x].son[p xor 1];
tr[y].sum:=tr[x].sum+1;
这两句要好好体会，对之后理解query过程中的语句很有帮助。
if (tr[tr[x].son[p xor 1]].sum=tr[tr[x].son[p xor 1]].sum) then...
刚开始曾经想过这个x已不一定在区间中，这样对吗？
我们分情况讨论，如果上述语句值为真，考虑右边的y，y就算不是右边界但显然是因为>y中的链已经不能满足走到当前步了。
再考虑左边界，如果一个在左边界以左的数都与后面的sum相等了，也就是[l,r]区间，以及其左边的一段都没有存在的链。
这种情况显然是对的。
如果不等呢？会因为左边界而导致原本应该不存在的链算入答案吗？
如果存在一个在[l,r]以左的x以右的链，那当前走到的一定是这条链...因为从insert过程可以看出，我们的插入是按照下标的顺序的
所以这种情况不存在，那不等的时候也是满足的。
这样一来，对于可持久化trie树就完全理解了。但是应用的时候还是要注意一些东西。
BZOJ3261
Description
给定一个非负整数序列 {a}，初始长度为 N。
有 M个操作，有以下两种操作类型：
1 、A x：添加操作，表示在序列末尾添加一个数 x，序列的长度 N+1。
2 、Q l r x：询问操作，你需要找到一个位置 p，满足 l<=p<=r，使得：
a[p] xor a[p+1] xor ... xor a[N] xor x 最大，输出最大是多少。
首先看到异或，还是可以比较自然地想到可持久化trie
然后对于题目让我们求的这一串东西，可以想到前缀和。
但由于异或运算的特殊性，设b[i]为1~i的异或和，b[i-1]^b[n]^x就是所求答案（∵ x^x=0）
A操作就是普通的insert操作，对于Q，我们只需要执行一次query操作即可。
在未学习可持久化trie之前这道题query的思维可圈可点 但是学习了以后再回头看就是一道简单的模板题了~
program bzoj3261; const maxn=14001000; var n,m,tot,tem,i,x,l,r:longint; ch:char; tr:array[-1..maxn]of record sum:longint;son:array[0..1]of longint;end; root,a:array[-1..maxn div 24]of longint; procedure insert(x:longint;var y:longint;ave,v:longint); var p:longint; begin inc(tot);y:=tot; tr[y].sum:=tr[x].sum+1; if v<0 then exit; p:=(ave >> v) and 1; tr[y].son[p xor 1]:=tr[x].son[p xor 1]; insert(tr[x].son[p],tr[y].son[p],ave,v-1); end; function query(x,y,ave,v:longint):longint; var p:longint; begin if v<0 then exit(0); p:=(ave >> v) and 1; if (tr[tr[x].son[p xor 1]].sum=tr[tr[y].son[p xor 1]].sum) then exit(query(tr[x].son[p],tr[y].son[p],ave,v-1)) else exit(query(tr[x].son[p xor 1],tr[y].son[p xor 1],ave,v-1)+1 << v); end; begin readln(n,m); tot:=0; insert(root[-1],root[0],0,24);
//这道题有个特殊之处在于0点也是要插入trie树的点
//因此要小心越界
//由于平时的习惯就是数组下标从-1开始，所以“好习惯能避免错误”^_^也是张老师说的
tem:=0; for i:=1 to n do begin read(a[i]); insert(root[i-1],root[i],a[i] xor tem,24); tem:=tem xor a[i]; end; readln; for i:=1 to m do begin read(ch); if ch='A' then begin inc(n);readln(a[n]); insert(root[n-1],root[n],a[n] xor tem,24); tem:=tem xor a[n]; end else begin readln(l,r,x); writeln(query(root[l-2],root[r-1],x xor tem,24)); end; end; end.
BZOJ3166：[Heoi2013]Alo
Description
Welcome to ALO ( Arithmetic and Logistic Online)。这是一个VR MMORPG ，
如名字所见，到处充满了数学的谜题。
现在你拥有n颗宝石，每颗宝石有一个能量密度，记为ai，这些宝石的能量
密度两两不同。现在你可以选取连续的一些宝石（必须多于一个）进行融合，设为 ai, ai+1, …, a j，则融合而成的宝石的能量密度为这些宝石中能量密度的次大值
与其他任意一颗宝石的能量密度按位异或的值，即，设该段宝石能量密度次大值
为k，则生成的宝石的能量密度为max{k xor ap | ap ≠ k , i ≤ p ≤ j}。
现在你需要知道你怎么选取需要融合的宝石，才能使生成的宝石能量密度最大。
首先这道题的解法是显而易见的...将每个数插入trie树中，然后我们最终答案所在的区间一定是极大区间
然后可以枚举次大值，显然当这个数定下来的时候，它存在两个极大区间
一个是它左边比它大的第二个数的下标+1~右边比它大的第一个数的下标-1
一个是它左边比它大的第一个数的下标+1~右边比它大的第二个数的下标-1
左右处理起来都一样~遇到的第一个数前几天正好做到过，用单调栈可以完美解决
至于第二大...我写的比较长
就是先按照值从大到小排序，然后用树状数组存以下标为下标的最大值和次大值，get的时候调的参数也是下标
为什么可以这样呢..?因为当初学树状数组的时候我就用它求过最大值，当时老师也很惊奇我居然可以那么写
但既然树状数组把1~i分成若干块，每一块都是到它前面一块的答案，那求最大值为何不可呢？
然后今天又用它来保存两个值..一个最大一个次大...感觉非常爽啊...
program bzoj3166; const maxn=2000010; var tot,ans,i,n,x,y:longint; a,l,r,opt,root,id,l2,r2,aa:array[-1..maxn div 30]of longint; tar:array[-1..maxn div 30]of record x,y:longint;end; tr:array[-1..maxn]of record sum:longint;son:array[0..1]of longint;end; function max(a,b:longint):longint; begin if a>b then exit(a) else exit(b); end; procedure swap(var x,y:longint); var tem:longint; begin tem:=x;x:=y;y:=tem; end; procedure insert(x:longint;var y:longint;ave,v:longint); var p:longint; begin inc(tot);y:=tot; tr[y].sum:=tr[x].sum+1; if v<0 then exit; p:=(ave >> v)and 1; tr[y].son[p xor 1]:=tr[x].son[p xor 1]; insert(tr[x].son[p],tr[y].son[p],ave,v-1); end; function query(x,y,ave,v:longint):longint; var p:longint; begin if v<0 then exit(0); p:=(ave >> v)and 1; if tr[tr[y].son[p xor 1]].sum=tr[tr[x].son[p xor 1]].sum then exit(query(tr[x].son[p],tr[y].son[p],ave,v-1)) else exit(query(tr[x].son[p xor 1],tr[y].son[p xor 1],ave,v-1)+1 << v); end; procedure qsort(L,R:longint); var i,j,mid:longint; begin i:=L;j:=R;mid:=a[random(R-L+1)+L]; repeat while (i<R)and(a[i]>mid) do inc(i); while (L<j)and(a[j]<mid) do dec(j); if i<=j then begin swap(a[i],a[j]);swap(id[i],id[j]); inc(i);dec(j); end; until i>j; if i<R then qsort(i,R); if L<j then qsort(L,j); end; procedure mend(x,y:longint); begin if y>tar[x].x then begin tar[x].y:=tar[x].x; tar[x].x:=y; end else if y>tar[x].y then tar[x].y:=y; end; procedure put(x,y:longint); begin if x=0 then begin mend(0,y); exit; end; while x<=n+1 do begin mend(x,y); x:=x+x and (-x); end; end; function get(x:longint):longint; var ans1,ans2,tem:longint; begin ans1:=tar[0].x;ans2:=tar[0].y; tem:=x; while x<>0 do begin if tar[x].x>ans1 then begin ans2:=ans1; ans1:=tar[x].x; end else if tar[x].x>ans2 then ans2:=tar[x].x; if tar[x].y>ans1 then begin ans2:=ans1; ans1:=tar[x].y; end else if tar[x].y>ans2 then ans2:=tar[x].y; x:=x-x and (-x); end; exit(ans2); end; procedure solve_lr; var i,tail:longint; begin a[0]:=maxlongint; tail:=1;opt[1]:=0; for i:=1 to n do begin while a[opt[tail]]<a[i] do dec(tail); l[i]:=opt[tail]; inc(tail);opt[tail]:=i; end; a[n+1]:=maxlongint; tail:=1;opt[1]:=n+1; for i:=n downto 1 do begin while a[opt[tail]]<a[i] do dec(tail); r[i]:=opt[tail]; inc(tail);opt[tail]:=i; end; for i:=1 to n+1 do id[i]:=i; qsort(0,n+1); fillchar(tar,sizeof(tar),0); for i:=0 to n+1 do begin l2[id[i]]:=get(id[i]); put(id[i],id[i]); end; fillchar(tar,sizeof(tar),0); for i:=0 to n+1 do begin r2[id[i]]:=n-get(n-id[i]+1)+1; put(n-id[i]+1,n-id[i]+1); end; end; begin readln(n); for i:=1 to n do read(a[i]); aa:=a; solve_lr; a:=aa; tot:=0;ans:=0; for i:=1 to n do insert(root[i-1],root[i],a[i],30); for i:=1 to n do begin x:=l2[i]+1;y:=r[i]-1; ans:=max(ans,query(root[x-1],root[y],a[i],30)); x:=l[i]+1;y:=r2[i]-1; ans:=max(ans,query(root[x-1],root[y],a[i],30)); end; writeln(ans); end.
感觉BZOJ对可持久化trie树特别偏爱，但是网上不像其他算法有大波的教程。
其实我觉得这个算法真的很优美 在异或的类型题中尤其好用
好好掌握 其实理解了之后根本不需要背
大概数据结构题就是这样形象的吧