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.

样例输入

样例输出

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 + ;

 int fa[N][], deep[N], head[N];

 int v[N], cnt;

 bool vis[N];

 int dp[N][];

 struct data

 {

     int to, next;

 }e[ * 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 = ; i <= ; i++)

         if (t&( << i)) x = fa[x][i];

     return x;

 }

 void dfs(int x)

 {

     vis[x] = ;

     for (int i = ; i <= ; i++)

     {

         if (deep[x]<( << i))break;

         fa[x][i] = fa[fa[x][i - ]][i - ];///倍增处理祖先信息

     }

     for (int k = ; k <= ; 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] + ;

         fa[e[i].to][] = 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 = ; i >= ; 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][];

 }

 void init()

 {

     cnt = ;

     memset(head, , sizeof(head));

     memset(vis, , sizeof(vis));

     memset(dp, , sizeof(dp));

     memset(deep, , sizeof(deep));

     memset(fa,,sizeof(fa));

 }

 int main()

 {

     int n, q;

     while (scanf("%d%d", &n, &q) != EOF)

     {

         init();

         for (int i = ; i<n; i++)

         {

             int x, y; scanf("%d%d", &x, &y);

             insert(x, y);

         }

         for (int i = ; i <= n; i++) scanf("%d", &v[i]);

         dfs();

         while (q--)

         {

             int x, y, k; scanf("%d%d%d", &x, &y, &k);

             int pa = lca(x, y);

             if (k <= )

             {

                 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<) 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\n", ans);

             }

             else

             {

                 int ans = ;

                 while ()

                 {

                     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<) goto endw;

                 t %= k;

                 y = cal(y, t);

                 while ()

                 {

                     ans ^= v[y];

                     if (deep[y] - k <= deep[pa]) break;

                     y = cal(y, k);

                 }

             endw:;

                 printf("%d\n", ans);

             }

         }

     }

     return ;

 }

 /**

 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

 */