FZU2176---easy problem （树链剖分）

http://acm.fzu.edu.cn/problem.php?pid=2176

Accept: 9 Submit: 32
Time Limit: 2000 mSec Memory Limit : 32768 KB

Problem Description

给定一棵n个节点以1为根的树，初始每个节点的值为0，现在我们要在树上进行一些操作，操作有两种类型。

1 x val 表示对以x为根的子树的每个点进行加权操作（我们定义每个节点的深度为每个节点到根1的距离），如果 y是以x为根的子树中的点那么 y节点的权值增加 (（dep[y]-dep[x]）%k+1)*val 其中dep[y]表示y节点的深度，k为一个常数(1<=k<=5)

2 x 查询当前x节点的权值。

Input

首先输入一个整数T 表示数据的组数，每组数据第一行有3个整数 n ，m， k（1<=n,m<=50000, 1<=k<=5）。n表示节点数，m表示操作数，k表示如题目描述的常数。

接下去n-1行描述一棵树。接下去m行每行表示一个操作有两种类型1 x val 表示第一种类型 2 x 表示第二种类型。(1<=x<=n,1<=val<=100)

Output

每组数据首先输出 Case#x: 表示第x组数据 x从1开始。接下去对于每组数据中的每个查询操作输出查询结果。（具体输出格式看样例）

Sample Input

5 7 2

1 2

2 4

2 5

1 3

1 2 3

1 1 2

2 1

2 2

2 3

2 4

2 5

Sample Output

Case#1:

大致思路：首先树链剖分一下，然后用树状数组或者线段树维护区间更新，但是(（dep[y]-dep[x]）%k+1)*val这种该怎么更新呢，，看到k很小最大只有5，可以想到用5棵线段树或者树状数组来维护。首先每个节点的深度dep确定后每隔k个深度权值增加的是相等的。这样的话就可以把所有的点对应到 k个树状数组上去。然后就是树状数组经典的区间更新单点查询操作了。

 #include <set>

 #include <map>

 #include <cmath>

 #include <ctime>

 #include <queue>

 #include <stack>

 #include <cstdio>

 #include <string>

 #include <vector>

 #include <cstdlib>

 #include <cstring>

 #include <iostream>

 #include <algorithm>

 using namespace std;

 typedef unsigned long long ull;

 typedef long long ll;

 const int inf = 0x3f3f3f3f;

 const double eps = 1e-;

 const int maxn = 5e4+;

 struct

 {

     int to,next;

 } e[maxn<<];

 int tot,head[maxn];

 void add_edge(int x,int y)

 {

     e[tot].to = y;

     e[tot].next = head[x];

     head[x] = tot++;

 }

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

 void dfs(int root)

 {

     siz[root] = ;

     son[root] = ;

     for (int i = head[root]; ~i; i = e[i].next)

     {

         if (fa[root] != e[i].to)

         {

             fa[e[i].to] = root;

             dep[e[i].to] = dep[root] + ;

             dfs(e[i].to);

             if (siz[e[i].to] > siz[son[root]])

                 son[root] = e[i].to;

             siz[root] += siz[e[i].to];

         }

     }

 }

 int pos[maxn],top[maxn],L[maxn],R[maxn],bj1,bj2,idx;

 void build (int root,int father)

 {

     pos[root] = ++idx;

     top[root] = father;

     L[root] = root;

     R[root] = root;

     if (son[root] > )

     {

         bj1 = son[root];

         build(son[root],top[root]);

         L[root] = bj1;

     }

     bool flag = ;

     for (int i = head[root]; ~i; i = e[i].next)

     {

         flag = ;

         if (fa[root] != e[i].to && son[root] != e[i].to)

             bj2 = e[i].to,build(e[i].to,e[i].to);

         else if (siz[root] == )

             bj2 = root;

     }

     if (flag)

         R[root] = bj2;

 }

 int lowbit(int x)

 {

     return x & -x;

 }

 int c[][maxn],n;

 void add(int x,int d,int k)

 {

     while (x <= n)

     {

         c[k][x] += d;

         x += lowbit(x);

     }

 }

 int sum(int x,int k)

 {

     int ans = ;

     while (x > )

     {

         ans += c[k][x];

         x -= lowbit(x);

     }

     return ans;

 }

 void init()

 {

     int root = ;

     tot = idx = ;

     dep[root] = fa[root] = ;

     memset(head,-,sizeof(head));

     memset(siz,,sizeof(siz));

     memset(c,,sizeof(c));

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

     {

         int u,v;

         scanf ("%d%d",&u,&v);

         add_edge(u,v);

         add_edge(v,u);

     }

     dfs(root);

     build(root,root);

 }

 int main(void)

 {

 #ifndef ONLINE_JUDGE

     freopen("in.txt","r",stdin);

 #endif

     int t,cas = ;

     scanf ("%d",&t);

     while (t--)

     {

         printf("Case#%d:\n",cas++);

         int k,m;

         scanf ("%d%d%d",&n,&m,&k);

         init();

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

         {

             int op,x,val;

             scanf ("%d%d",&op,&x);

             if (op == )

             {

                 scanf ("%d",&val);

                 for (int j = ; j < k; j++)

                 {

                     int tmp = (j + ) * val;

                     int l = pos[x];

                     int r = pos[R[x]];

                     add(pos[x], tmp,((dep[x] + )%k + j)%k);

                     add(pos[R[x]] + , -tmp,((dep[x] + )%k + j)%k);

                 }

             }

             if (op == )

             {

                 printf("%d\n",sum(pos[x],(dep[x]-dep[] + ) % k));

             }

         }

     }

     return ;

 }