hdu 5274 Dylans loves tree 树剖

题意：给出一棵树及树上点权值，每次可更改某点权值 或者 查询某条路径上点权出现次数为奇数的那个点权是多少。

因为每次一条路径上出现奇数次点权最多只有一个，而点权出现次数为偶数的时候是可以通过异或消去的，那么直接套树剖+线段树维护就行了。

这里有个坑点，即点权为0，那么出现0 0 0的时候异或值为0，但是0这个点权还是出现了三次。应该输出0，解决办法可以在线段树上多维护一个0的个数，或者点权+1，这样就保证所以得点权非0，记得在更改的时候也要使被更改的点权+1

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <algorithm>
using namespace std;

#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
#define ls rt << 1
#define rs rt << 1 | 1
#define pi acos(-1.0)
#define eps 1e-8
#define asd puts("sdfsdfsdfsdfsdfsdf");
typedef __int64 ll;
typedef pair<int, int> pll;
const int N = 100010;
struct node{
     int v, nxt;
}e[N<<1];

int head[N];
int pos[N];
int pre[N];
int son[N];
int sz[N];
int top[N];
int dep[N];
int n, q, cnt, ID;
int val[N];

void init()
{
    memset( head, -1, sizeof( head ) );
    ID = cnt = 0;
    dep[1] = sz[0] = 0;
}

void add( int u, int v )
{
    e[cnt].v = v;
    e[cnt].nxt = head[u];
    head[u] = cnt++;

    e[cnt].v = u;
    e[cnt].nxt = head[v];
    head[v] = cnt++;
}

void dfs( int u )
{
    sz[u] = 1;
    son[u] = 0;
    for( int i = head[u]; ~i; i = e[i].nxt ) {
        int v = e[i].v;
        if( v == pre[u] )
            continue;
        dep[v] = dep[u] + 1;
        pre[v] = u;
        dfs( v );
        sz[u] += sz[v];
        if( sz[v] > sz[son[u]] )
            son[u] = v;
    }
}

void rebuild( int u, int anc )
{
    pos[u] = ++ID;
    top[u] = anc;
    if( son[u] )
        rebuild( son[u], anc );
    for( int i = head[u]; ~i; i = e[i].nxt ) {
        int v = e[i].v;
        if( v != pre[u] && v != son[u] )
            rebuild( v, v );
    }
}

struct seg{
    int l, r, x;
}tr[N<<2];

void pushup( int rt )
{
    tr[rt].x = tr[ls].x ^ tr[rs].x;
}

void build( int l, int r, int rt )
{
    tr[rt].l = l;
    tr[rt].r = r;
    if( l == r ) {
        tr[rt].x = val[l];
        return;
    }
    int mid = ( l + r ) >> 1;
    build( lson );
    build( rson );
    pushup( rt );
}

void update( int pos, int xx, int rt )
{
    if( tr[rt].l == tr[rt].r && tr[rt].l == pos ) {
        tr[rt].x = xx;
        return;
    }
    int mid = ( tr[rt].l + tr[rt].r ) >> 1;
    if( pos <= mid )
        update( pos, xx, ls );
    else
        update( pos, xx, rs );
    pushup( rt );
}

int query( int l, int r, int rt )
{
    if( l <= tr[rt].l && tr[rt].r <= r ) {
        return tr[rt].x;
    }
    int mid = ( tr[rt].l + tr[rt].r ) >> 1;
    if( r <= mid )
        return query( l, r, ls );
    else if( l > mid )
        return query( l, r, rs );
    else
        return query( lson ) ^ query( rson );
}

int query_res( int x, int y )
{
    int cur = 0;
    while( top[x] != top[y] ) {
        int f1 = top[x], f2 = top[y];
        if( dep[f1] > dep[f2] ) {
            cur ^= query( pos[f1], pos[x], 1 );
            x = pre[f1];
        }
        else {
            cur ^= query( pos[f2], pos[y], 1 );
            y = pre[f2];
        }
    }
    if( dep[x] < dep[y] )
        return cur ^ query( pos[x], pos[y], 1 );
    else
        return cur ^ query( pos[y], pos[x], 1 );
}

int main()
{
    int tot;
    scanf("%d", &tot);
    while( tot-- ) {
        scanf("%d%d", &n, &q);
        init();
        int u, v, op;
        for( int i = 1; i < n; ++i ) {
            scanf("%d%d", &u, &v);
            add( u, v );
        }
        dfs( 1 );
        rebuild( 1, 1 );
        for( int i = 1; i <= n; ++i ) {
            int x;
            scanf("%d", &x);
            ++x;
            val[pos[i]] = x;
        }
        build( 1, n, 1 );
        while( q-- ) {
            scanf("%d%d%d", &op, &u, &v);
            if( op == 0 )
                update( pos[u], v+1, 1 );
            else {
                int f = query_res( u, v );
                if( f )
                    printf("%d\n", f-1);
                else
                    printf("-1\n");
            }
        }
    }
    return 0;
}