HDU5274 Dylans loves tree(树链剖分线段树)

给定n个节点的树，q次操作$(1 \leq n,q \leq 10^5)$，每个节点的权值$0 \leq a[i] \leq 10^5$。
操作分两类
0 x y 表示把编号为x的节点权值修改为y
1 x y 表示询问x到y的路径上出现的每一种点权是否都出现了偶数次，若是输出-1，否者输出那个 出现奇数次的点权（保证每次询问最多经过1种出现次数为奇数的点权）
有一个很神奇的性质，$a⊕a = 0，a⊕0 = a，$推广一下偶数个a异或的值为0，奇数个a异或的值为a。
而且输入保证每次询问最多经过一个奇数，也就是不会出现$a⊕b=c$的情况，那么我们就可以放心大胆的用一棵线段树维护$[l,r]$上所有数异或的值。当这个值为0的时候，这个区间每一种点权出现了偶数次或者0出现了奇数次。只要在输入的时候把每个点权+1就易于区分到底是哪种情况.

#include<cstdio>
#include<iostream>
#include<cstring>
#define MAXN 100010
using namespace std;
struct Edge
{
    int v,next;
}edge[MAXN*2];
int head[MAXN],cnt;
void add_edge(int u,int v)
{
    edge[cnt].v = v;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}
int n,q,ops,a[MAXN],x,y;
int htp[MAXN],son[MAXN],sz[MAXN],fa[MAXN],dep[MAXN];
int tid[MAXN],rnk[MAXN],dcnt;
void dfs1(int u,int f)
{
    sz[u] = 1;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].v;
        if(v == f) continue;
        fa[v] = u;
        dep[v] = dep[u]+1;
        dfs1(v,u);
        sz[u] += sz[v];
        if(sz[v] > sz[son[u]]) son[u] = v;
    }
}
void dfs2(int u,int tp)
{
    htp[u] = tp;
    tid[u] = ++dcnt;
    rnk[dcnt] = u;
    if(son[u] == 0) return;
    dfs2(son[u],tp);
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].v;
        if(v == son[u]||v == fa[u]) continue;
        dfs2(v,v);
    }
}
struct tr
{
    int l,r,sum;
}tree[MAXN*4];
void build_tree(int i,int l,int r)
{
    tree[i].l = l;
    tree[i].r = r;
    if(l == r)
    {
        tree[i].sum = a[rnk[l]];
        return;
    }
    int mid = (l+r)/2;
    build_tree(i*2,l,mid);
    build_tree(i*2+1,mid+1,r);
    tree[i].sum = tree[i*2].sum^tree[i*2+1].sum;
}
void update(int i,int u,int val)
{
    if(tree[i].l == u&&tree[i].r == u)
    {
        tree[i].sum = val;
        return;
    }
    int mid = (tree[i].l+tree[i].r)/2;
    if(u <= mid) update(i*2,u,val);
    else update(i*2+1,u,val);
    tree[i].sum = tree[i*2].sum^tree[i*2+1].sum;
}
int query(int i,int l,int r)
{
    if(tree[i].l == l&&tree[i].r == r)
    {
        return tree[i].sum;
    }
    int mid = (tree[i].l+tree[i].r)/2;
    if(r <= mid) return query(i*2,l,r);
    else if(l > mid) return query(i*2+1,l,r);
    else return query(i*2,l,mid)^query(i*2+1,mid+1,r);
}
int change(int u,int v)
{
    int ans = 0;
    while(htp[u] != htp[v])
    {
        if(dep[htp[u]] < dep[htp[v]]) swap(u,v);
        ans = ans^query(1,tid[htp[u]],tid[u]);
        u = fa[htp[u]];
    }
    if(dep[u] < dep[v]) swap(u,v);
    ans = ans^query(1,tid[v],tid[u]);
    return ans;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {    
        memset(head,-1,sizeof head);
        memset(sz,0,sizeof sz);
        memset(son,0,sizeof son);
        memset(tid,0,sizeof tid);
        memset(rnk,0,sizeof rnk);
        memset(fa,0,sizeof fa);
        cnt = dcnt = 0;        
        scanf("%d%d",&n,&q);
        for(int i = 1; i < n; i++)
        {
            scanf("%d%d",&x,&y);
            add_edge(x,y);
            add_edge(y,x);
        }
        for(int i = 1; i <= n; i++)
        {   
            scanf("%d",&a[i]);
            a[i]++;
        }   
        dfs1(1,-1);
        dfs2(1,1);
        build_tree(1,1,n);
        for(int i = 1; i <= q; i++)
        {
            scanf("%d%d%d",&ops,&x,&y);
            if(ops == 0)
                update(1,tid[x],++y);
            else
            {
                int ans = change(x,y);
                if(ans == 0) printf("-1\n");
                else printf("%d\n",--ans);
            }
        }
    }    
}