HDU 5274 Dylans loves tree 树链剖分

传送门： http://acm.hdu.edu.cn/showproblem.php?pid=5274

题意

$给一个树，每个节点都有权值，有两种操作：$

1.$0xy将x的权值改成y$
2. $1xy将树上x到y的最短路径上权值出现奇数次的权值输出来，没有输出-1$

$题目保证x到y的最短路径的出现次数的权值的奇数次最多有一个，（可能是0个）。$

思路

$题目查询的树上x到y的最短路径，所以可以用树链剖分。$
$而且题目说奇数个最多出现1个，所以我们可以用树状数组维护区间异或和。$

因为偶数次的异或和为0，但是如果区间的a[i]全是0，但是出现偶数次，那答案是-1，而不是0，所以我们维护w[i]+1，最后查询的答案-1，这样即使是0，也正好输出-1。

Code（218MS）

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pdd;

#define INF 0x3f3f3f3f
#define lowbit(x) x & (-x)
#define mem(a, b) memset(a , b , sizeof(a))
#define FOR(i, x, n) for(int i = x;i <= n; i++)

// const ll mod = 998244353;
// const ll mod = 1e9 + 7;
// const double eps = 1e-6;
// const double PI = acos(-1);
// const double R = 0.57721566490153286060651209;

const int maxn = 1e5 + 10;

struct Edge {
    int v, next;
}e[maxn << 1];
int head[maxn], cnt;

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

int fa[maxn], dep[maxn], siz[maxn], son[maxn];

void dfs1(int u, int par) {
    dep[u] = dep[fa[u] = par] + (siz[u] = 1);
    for(int i = head[u]; i ; i = e[i].next) {
        int v = e[i].v;
        if(v == par) continue;
        dfs1(v, u);
        siz[u] += siz[v];
        if(!son[u] || siz[v] > siz[son[u]]) {
            son[u] = v;
        }
    }
}

int tim, dfn[maxn], top[maxn], nodeof[maxn];

void dfs2(int u, int topf) {
    nodeof[dfn[u] = ++tim] = u;
    top[u] = topf;
    if(!son[u]) return ;
    dfs2(son[u], topf);
    for(int i = head[u]; i; i = e[i].next) {
        int v = e[i].v;
        if(v == son[u] || v == fa[u]) continue;
        dfs2(v, v);
    }
}

int w[maxn], n;

#define lowbit(x) x & (-x)

int t[maxn];

void modify(int x, int val) {
    while(x <= n) {
        t[x] ^= val;
        x += lowbit(x);
    }
}

int query(int x) {
    int ans = 0;
    while(x) {
        ans ^= t[x];
        x -= lowbit(x);
    }
    return ans;
}

int query_chain(int x, int y) {
    int ans = 0;
    while(top[x] != top[y]) {
        if(dep[top[x]] < dep[top[y]]) swap(x, y);
        ans ^= (query(dfn[top[x]] - 1) ^ query(dfn[x]));
        x = fa[top[x]];
    }
    if(dep[x] > dep[y]) swap(x, y);
    ans ^= (query(x - 1) ^ query(y));
    return ans;
}

void solve() {
    int m; cin >> n >> m;
    for(int i = 1;i <= n - 1; i++) {
        int u, v; cin >> u >> v;
        add(u, v);
        add(v, u);
    }
    dfs1(1, 0);
    dfs2(1, 1);
    for(int i = 1;i <= n; i++) {
        cin >> w[i];
        w[i]++;
        modify(dfn[i], w[i]);
    }
    while(m--) {
        int opt, x, y; cin >> opt >> x >> y;
        if(opt == 0) {
            modify(dfn[x], w[x]);
            modify(dfn[x], w[x] = y + 1);
        }
        else {
            cout << query_chain(x, y) - 1 << endl;
        }
    }
}

int main() {
    solve();
}