HDU 4757 Tree(可持续化字典树，lca)

题意：询问树上结点x到结点y路上上的权值异或z的最大值。

任意结点权值 ≤ 2^16，可以想到用字典树。

但是因为是询问某条路径上的字典树，将字典树可持续化，字典树上的结点保存在这条路径上的二进制数。

按照dfs序建树，结点u的字典树表示u到根结点路径上的字典树。

如果两个结点u和v，在同一条通往根结点的路径上，将会满足可减性。

因此只需要知道u、v、lca和fa[lca]四个结点的字典树就可以回答了。

/*********************************************************
*            ------------------                          *
*   author AbyssFish                                     *
**********************************************************/
#include<cstdio>
#include<iostream>
#include<string>
#include<cstring>
#include<queue>
#include<vector>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
#include<cmath>
#include<numeric>
#include<climits>
using namespace std;

const int maxn = 1e5+;
const int maxd = ;
const int maxnds = (maxd+)*maxn;

int hd[maxn], nx[maxn<<], to[maxn<<], ec;
void add_edge(int u,int v)
{
    nx[ec] = hd[u];
    to[ec] = v;
    hd[u] = ec++;
}
void init_g(int n){ memset(hd+,0xff,n*sizeof(int)); ec = ; }
#define eachedge int i = hd[u]; ~i; i = nx[i]
#define ifvalid int v = to[i]; if(v == fa[u]) continue;

struct Node
{
    int ch[];
    int v;
}p[maxnds];
int tot;

int n,m;
int stk[maxd+];

inline int *dcmp(int x)
{
    for(int i = ; i < maxd; i++){
        stk[i] = x>>i&;
    }
    return stk;
}

void build(int *o, int v)
{
    int *s = dcmp(v);
    for(int i = maxd-; i >= ; i--){
        o = &(p[*o].ch[s[i]]);
        p[++tot] = p[*o];
        *o = tot;
        p[*o].v++;
    }
}

int a[maxn];
int fa[maxn];
int root[maxn];

void dfs_build(int u,int f = )
{
    p[root[u] = ++tot] = p[root[fa[u] = f]];
    build(root+u,a[u]);
    for(eachedge){
        ifvalid
        dfs_build(v,u);
    }

}

int *c_cmp;
bool cmp_id(int i,int j){ return c_cmp[i] < c_cmp[j]; }

int dep[maxn];
int path[maxn<<];
int pid[maxn];
int dfs_clk;

void get_path(int u,int d)
{
    dep[u] = d;
    path[++dfs_clk] = u;
    pid[u] = dfs_clk;
    for(eachedge){
        ifvalid
        get_path(v,d+);
        path[++dfs_clk] = u;
    }
}

struct SparseTable
{
    int mxk[maxn<<];
    int d[maxn<<][];
    void init(int *mp,int *r, int n)
    {
        mxk[] = -;
        for(int i = ; i <= n; i++){
            d[i][] = r[i];
            mxk[i] = ((i&(i-)) == ) ?mxk[i-]+:mxk[i-];
        }
        c_cmp = mp;
        for(int j = ; j <= mxk[n]; j++){
            int t = (<<j)-, s = <<(j-);
            for(int i = ; i + t <= n; i++){
                d[i][j] = min(d[i][j-],d[i+s][j-],cmp_id);
            }
        }

    }
    int RMQ(int l,int r)
    {
        int k = mxk[r-l];
        return min(d[l][k],d[r-(<<k)][k],cmp_id);
    }
}rmq;

void lca_init(int u)
{
    dfs_clk = ;
    get_path(u,);
    rmq.init(dep,path,dfs_clk);
}

int q_lca(int u, int v)
{
    if(pid[u] > pid[v]) swap(u,v);
    return rmq.RMQ(pid[u],pid[v]+);
}

vector<int> Tree;

int cal_ch(int d)
{
    int re = ;
    for(int i = ; i < (int)Tree.size(); i++){
        int o = Tree[i];
        re += o >= ? p[p[o].ch[d]].v : -p[p[-o].ch[d]].v;
    }
    return re;
}

void dump(int d)
{
    for(int i = ; i < (int)Tree.size(); i++){
        int &o = Tree[i];
        o = o >= ? p[o].ch[d] : -p[-o].ch[d];
    }
}

int query(int x,int y,int z)
{
    int re = z&~((<<)-);
    int *s = dcmp(z);
    Tree.clear();
    Tree.push_back(root[x]);
    Tree.push_back(root[y]);
    int lca = q_lca(x,y);
    Tree.push_back(-root[lca]);
    Tree.push_back(-root[fa[lca]]);

    int tmp = ;
    for(int i = maxd-; i >= ; i--, tmp <<= ){
        int d = s[i]^;
        if(cal_ch(d)){
            tmp |= ;
            dump(d);
        }
        else dump(d^);
    }
    return re|(tmp>>);
}

void solve()
{
    for(int i = ; i <= n; i++){
        scanf("%d",a+i);
    }
    init_g(n);
    for(int i = ,u,v; i < n; i++){
        scanf("%d%d",&u,&v);
        add_edge(u,v);
        add_edge(v,u);
    }
    tot = ;
    dfs_build();
    lca_init();
    for(int i = , x, y, z; i < m; i++){
        scanf("%d%d%d",&x,&y,&z);
        printf("%d\n",query(x,y,z));
    }
}

//#define LOCAL
int main()
{
#ifdef LOCAL
    freopen("in.txt","r",stdin);
#endif
    //p[0] = {{0,0},0}; //root[0] = 0;
    while(~scanf("%d%d",&n,&m)){
        solve();
    }
    return ;
}