[可持久化Trie][HDU4757] Tree

恩，刚学了一发可持久化Trie树，其实挺简单的。。

反正可持久化数据结构都一个样嘛，动态加点就好了。

还是写一篇博客给自己看吧。

因为树上的路径嘛，肯定要想到把路径分成两部分，x->lca(x,y) 和 y->lca(x,y) 。 这就相当与两块区间，然后求单点异或最大值，自然就想到可持久化了呗。（想想你怎么用可持久化线段树求区间第k大（小）就好了）。只需要按照遍历顺序把点权以二进制的形式插入Trie树。新的版本从它的父亲节点的版本那继承就好了。

(p:我用倍增求的lca)

插入的时候把路径上的每个点的cnt+1，这样处理，你用x的版本减去lca（x,y)的版本就可以得到了x->lca(x,y)路径上有哪些点的点权啦。

然后根据Trie树贪心就好，尽量使每一位都和z不同。

因为trie树存的是二进制嘛，如果，z的某一位是1的话，你就看有没有这一位是0的数，如果有就走ch[0],不然你就只能走ch[1]了。。

这样满足高位最大，答案就最优，所以你的trie树肯定从高位存到低位啦，最高位设为17就好，反正最大才16。

emmmmm... 然后感觉就没什么了，不过有个细节。

多组数据 多组数据 多组数据

重要的事说三遍，不要问我WA了多少次。。

如果你有点儿迷糊，去敲一敲可持久化线段树就好了。

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#define LL long long
#define pch putchar
#define gch getchar
#define mem(k) memset(k,0,sizeof k)
using namespace std;

const int MAXN=100000+5;
const int MAXM=100000+5;

int n,m;
    
int cnt,root[MAXN];

struct Tree{
    int ch[2],pos,cnt;
}tree[MAXN*2*20+MAXM*20];//空间你就估摸着开吧，每次插入新增17个点。 

int head[MAXN],cou,a[MAXN],d[MAXN],p[MAXN][20];

struct ROAD{
    int v,next;
}road[MAXN<<1];

inline int insert(int x,int pre,int pos){//可持久化插入操作。 
    int now=++cnt;
    tree[now].pos=pos;
    tree[now].ch[0]=tree[pre].ch[0];
    tree[now].ch[1]=tree[pre].ch[1];
    tree[now].cnt=tree[pre].cnt+1;
    if(pos==0) return now;
    if(1<<(pos-1)&x) tree[now].ch[1]=insert(x,tree[pre].ch[1],pos-1);//判断下一位。 
    else tree[now].ch[0]=insert(x,tree[pre].ch[0],pos-1);
    return now;
}

inline void add_edge(int x,int y){//加边。 
    road[++cou].v=y;
    road[cou].next=head[x];
    head[x]=cou;
}

inline void dfs(int now,int fa){//遍历原树，处理出稀疏表，把点权插进Trie树，当然是可持久化的操作。 
    root[now]=insert(a[now],root[fa],17);
    d[now]=d[fa]+1;
    p[now][0]=fa;
    for(int i=1;i<=17;++i){
        p[now][i]=p[p[now][i-1]][i-1];
    }
    for(int i=head[now];i!=-1;i=road[i].next){
        int v=road[i].v;
        if(fa==v) continue;
        dfs(v,now);
    }
}

inline int LCA(int x,int y){//倍增LCA。 
    if(d[x]<d[y]) swap(x,y);
    for(int i=17;i>=0;--i){
        if(d[p[x][i]]<d[y]) continue;
        x=p[x][i];
        if(d[x]==d[y]) break;
    }
    if(x==y) return x;
    for(int i=17;i>=0;--i){
        if(p[x][i]!=p[y][i]){
            x=p[x][i];
            y=p[y][i];
        }
    }
    return p[x][0];
}

inline int ask(int now,int pre,int x){//Trie树上做减法。 
    int pos=tree[now].pos;
    if(pos==0) return 0;
    int next=(1<<(pos-1)&x)?0:1;//你想要的数。 
    int son[2];
    son[0]=tree[tree[now].ch[0]].cnt-tree[tree[pre].ch[0]].cnt;
    son[1]=tree[tree[now].ch[1]].cnt-tree[tree[pre].ch[1]].cnt;
    int ans=0;
    if(son[next]) ans^=(1<<(pos-1)),ans^=ask(tree[now].ch[next],tree[pre].ch[next],x);
    else if(son[next^1]) ans^=ask(tree[now].ch[next^1],tree[pre].ch[next^1],x);
    else return 0;
    return ans;
}

inline int query(int x,int y,int z){//分两部分 分别 ask 就好了。 
    int ans=0;int lca=LCA(x,y);
    ans=a[lca]^z;
    ans=max(ans,ask(root[x],root[lca],z));
    ans=max(ans,ask(root[y],root[lca],z));
    return ans;
}

int main(){
    while(scanf("%d%d",&n,&m)!=EOF){
        cnt=0;cou=0;
        mem(root);mem(a);mem(d);mem(p);
        memset(head,-1,sizeof head);
        for(int i=1;i<=n;++i) scanf("%d",&a[i]);
        for(int i=1;i<n;++i){
            int x,y;scanf("%d%d",&x,&y);
            add_edge(x,y);add_edge(y,x);
        }
        dfs(1,0);
        for(int i=1;i<=m;++i){
            int x,y,z;scanf("%d%d%d",&x,&y,&z);
            printf("%d\n",query(x,y,z));
        }
    }
    return 0;
}