2017 ICPC网络赛（西安）--- Xor

题目连接

Problem

There is a tree with n nodes. For each node, there is an integer value ai, (1≤ai​≤1,000,000,000 for 1≤i≤n). There is q queries which are described as follow:

Assume the value on the path from node a to node b is t0​,t1​,⋯tm​. You are supposed to calculate t0 xor tk xor t2k xor ... xor tpk (pk≤m).

Input Format

There are multi datasets. (∑n≤50,000,∑q≤500,000).

For each dataset: In the first n−1 lines, there are two integers u,v, indicates there is an edge connect node uand node v.

In the next nn lines, There is an integer ai​ (1≤ai​≤1,000,000,000).

In the next q lines, There is three integers a,b and k. (1≤a,b,k≤n).

Output Format

For each query, output an integer in one line, without any additional space.

样例输入

5 6
1 5
4 1
2 1
3 2
19
26
0
8
17
5 5 1
1 3 2
3 2 1
5 4 2
3 4 4
1 4 5

样例输出

17
19
26
25
0
19

题意： 有一棵n个节点的树，每个节点上有个权值vi，现在q次询问：节点a到节点b的路径上，从a开始每k个节点跳一次所经过的所有节点的异或值为（a0,ak,a2k,a3k...）？

思路： 建树，倍增算法记录每个节点的深度和2^i的祖先，处理并记录每个节点i到根节点间隔为k（1,2,3……100）的异或值dp[i][k]。当k<=100时，使用记录的异或值dp计算a到b间隔为k的异或值；当k>100时，直接从a走到b，每次跳动使用倍增的信息（快速跳动）。

注：这道题是2017年打西安网络赛时没过的题，当时其实代码写的很接近了，测数据都没问题，一直检查不出来，我也一直惦记着这道题。本科毕业后读研，又看过一次还是没找出原因，今天五一放假，没啥事儿，我又看了一遍当时写的代码，突然发现没初始化fa数组，心想难道是计蒜客网站编译器不是默认未初始化的值为0？加上fa的初始化后提交了一把，过了！！！
My God！ 心心念念的这道题竟然是这个原因没过，气呀。不过，今天总算是找到原因了，哈哈~  又一次想起来西安正式赛的时候，一道铜牌题没过“LOL BP”导致没拿到银牌，可惜的是当时的银牌题都过了，唉~ 与银失之交臂。现在是研究生了，很少刷题了，以后要少看剧，多看看相关的图形学的专业书，充实自己，找个好工作。

代码如下：

//https://nanti.jisuanke.com/t/A1273 《Xor》
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
const int N = 5e4 + 5;
int fa[N][20], deep[N], head[N];
int v[N], cnt;
bool vis[N];
int dp[N][105];
struct data
{
    int to, next;
}e[2 * N];

void insert(int u, int v)
{
    e[++cnt].to = v;
    e[cnt].next = head[u];
    head[u] = cnt;
    e[++cnt].to = u;
    e[cnt].next = head[v];
    head[v] = cnt;
}
int cal(int x, int t)
{
    for (int i = 0; i <= 19; i++)
        if (t&(1 << i)) x = fa[x][i];
    return x;
}
void dfs(int x)
{
    vis[x] = 1;
    for (int i = 1; i <= 19; i++)
    {
        if (deep[x]<(1 << i))break;
        fa[x][i] = fa[fa[x][i - 1]][i - 1];///倍增处理祖先信息
    }
    for (int k = 1; k <= 100; k++)
    {
        dp[x][k] = v[x];
        if (deep[x]<k) continue;
        int p = cal(x, k);
        dp[x][k] ^= dp[p][k];
    }
    for (int i = head[x]; i; i = e[i].next)
    {
        if (vis[e[i].to]) continue;
        deep[e[i].to] = deep[x] + 1;
        fa[e[i].to][0] = x;
        dfs(e[i].to);
    }
}
int lca(int x, int y)///求lca
{
    if (deep[x]<deep[y]) swap(x, y);
    x = cal(x, deep[x] - deep[y]);
    for (int i = 19; i >= 0; i--)
        if (fa[x][i] != fa[y][i])
        {
            x = fa[x][i];
            y = fa[y][i];
        }
    if (x == y)return x;
    else return fa[x][0];
}

void init()
{
    cnt = 0;
    memset(head, 0, sizeof(head));
    memset(vis, 0, sizeof(vis));
    memset(dp, 0, sizeof(dp));
    memset(deep, 0, sizeof(deep));
    memset(fa,0,sizeof(fa));
}

int main()
{
    int n, q;
    while (scanf("%d%d", &n, &q) != EOF)
    {
        init();
        for (int i = 1; i<n; i++)
        {
            int x, y; scanf("%d%d", &x, &y);
            insert(x, y);
        }
        for (int i = 1; i <= n; i++) scanf("%d", &v[i]);
        dfs(1);
        while (q--)
        {
            int x, y, k; scanf("%d%d%d", &x, &y, &k);
            int pa = lca(x, y);
            if (k <= 100)
            {
                int ans = dp[x][k];
                int h = (deep[x] - deep[pa]) % k;
                int t = k - h;
                if (deep[pa] >= t)
                {
                    int l = cal(pa, t);
                    ans ^= dp[l][k];
                }
                int r = k - h;
                t = deep[y] - deep[pa] - r;
                if (t<0) goto endw2;
                t %= k;
                y = cal(y, t);///
                ans ^= dp[y][k];
                t = k - r;
                if (deep[pa] >= t)
                {
                    int l = cal(pa, t);
                    ans ^= dp[l][k];
                }
            endw2:;
                printf("%d
", ans);
            }
            else
            {
                int ans = 0;
                while (1)
                {
                    ans ^= v[x];
                    if (deep[x] - k<deep[pa]) break;
                    x = cal(x, k);
                }
                int l = k - (deep[x] - deep[pa]);
                int t = deep[y] - deep[pa] - l;
                if (t<0) goto endw;
                t %= k;
                y = cal(y, t);
                while (1)
                {
                    ans ^= v[y];
                    if (deep[y] - k <= deep[pa]) break;
                    y = cal(y, k);
                }
            endw:;
                printf("%d
", ans);
            }
        }
    }
    return 0;
}
/**
8 11
1 2
2 3
2 4
1 5
5 6
5 7
4 8
3 5 6 2 7 0 1 10
1 8 1
answer=14
*/