沈阳网络赛J-Ka Chang【分块】【树状数组】【dfs序】

Given a rooted tree ( the root is node 11 ) of NN nodes. Initially, each node has zero point.

Then, you need to handle QQ operations. There're two types:

1\ L\ X1 L X: Increase points by XX of all nodes whose depth equals LL ( the depth of the root is zero ). (x \leq 10^8)(x≤108)

2\ X2 X: Output sum of all points in the subtree whose root is XX.

Input

Just one case.

The first lines contain two integer, N,QN,Q. (N \leq 10^5, Q \leq 10^5)(N≤105,Q≤105).

The next n-1n−1 lines: Each line has two integer aa,bb, means that node aa is the father of node bb. It's guaranteed that the input data forms a rooted tree and node 11 is the root of it.

The next QQ lines are queries.

Output

For each query 22, you should output a number means answer.

样例输入复制

3 3
1 2
2 3
1 1 1
2 1
2 3

样例输出复制

1
0

题目来源

ACM-ICPC 2018 沈阳赛区网络预赛

题意：

有一棵树 两种操作

一种是 将深度为i的所有节点的值加x

一种是 求以x为根的子树的所有节点之和

题解：

比赛的时候想到线段树 + dfs序了

也想到了将深度相同的节点用数组存

但是后面担心没办法维护修改 就有点不太会了

今天看题解的时候看到有一个人说  “ 一看这种没有办法直接用数据结构解决得问题就要考虑分块。”【学到了学到了】

对于同一深度设一个阈值limit,若这一深度中结点的个数>limit,则不实际进行更改,而是用一个数组来标记,因为>limit的层数不会太多,所以可以直接暴力枚举所有超越阈值的层数对于答案的贡献,同时二分答案即可。

节点数>block的为第一类，节点数<=为第二类。

对于第二类，每次修改操作我们暴力修改每个结点的影响值，因为涉及线段树或者树状数组的操作，时间复杂度为O（q*block*logn）。而每次通过线段树查询都是logn的

对于第一类，当修改的时候直接记录这一层被增加了多少，O（1）修改，然后查询的时候只需要枚举第二类的每一层，然后以这个结点为根节点的子树中属于这一层的节点数*这一层增加的值。这里的时间复杂度是O（q*n/block）

我们需要预处理出每个结点的子树中属于第一类层的节点数各有多少。这里我用的办法就是直接暴力。枚举每个点，如果它所在的层是第一类，那么更新它所有的父节点。这里的时间复杂度很容易被认为是O(n^2）。但是我们仔细分析一下发现它远远小于O(n^2)。因为最多有n/block层，所以这里的时间复杂度是O（n*n/block）

先不考虑预处理，只看操作的时间复杂度是O(q*block*logn+q*n/block).根据均值不等式最小是O（q*2*sqrt(nlogn)），当且仅当block取sqrt(n/logn)。这时候预处理的时间复杂度是O（n*sqrt(n*logn)）经过计算时可以承受的（因为只有单组数据）。

 // ConsoleApplication3.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
 //

 //#include "pch.h"
 #include <iostream>
 #include<algorithm>
 #include<stdio.h>
 #include<set>
 #include<cmath>
 #include<cstring>
 #include<map>
 #include<vector>
 #include<queue>
 #include<stack>

 #define inf 0x3f3f3f3f

 using namespace std;

 typedef long long LL;

 const int maxn = 1e5 + ;
 int n, q;
 struct edge{
     int v, nxt;
 }e[maxn << ];
 int head[maxn], cnt;
 int cntid, st[maxn], ed[maxn];
 vector<int>dep[maxn];
 vector<int>large;
 LL sum[maxn], num[maxn];

 void init()
 {
     memset(head, -, sizeof(head));
     memset(sum, , sizeof(sum));
     memset(num, , sizeof(num));
     cnt = ;
     cntid = ;
 }

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

 void dfs(int u, int fa, int depth)
 {
     st[u] = ++cntid;
     dep[depth].push_back(cntid);
     for(int i = head[u]; i != -; i = e[i].nxt){
         int v = e[i].v;
         if(v != fa){
             dfs(v, u, depth + );
         }
     }
     ed[u] = cntid;
 }

 void add(int pos, LL x)
 {
     while(pos <= n){
         sum[pos] += x;
         pos += (pos & -pos);
     }
 }

 LL query(int pos)
 {
     LL ans = ;
     while(pos){
         ans += sum[pos];
         pos -= (pos & -pos);
     }
     return ans;
 }

 int main()
 {
     init();
     scanf("%d%d", &n, &q);
     for(int i = ; i < n; i++){
         int u, v;
         scanf("%d%d", &u, &v);
         addedge(u, v);
         addedge(v, u);
     }
     dfs(, , );
     //cout<<"y"<<endl;
     int block = ceil(sqrt(n));
     for(int i = ; i < n; i++){//节点大于阈值的层
         if(dep[i].size() > block){
             large.push_back(i);
         }
     }

     while(q--){
         int op;
         scanf("%d", &op);
         if(op == ){
             int d;
             LL x;
             scanf("%d%lld", &d, &x);
             if(dep[d].size() > block){
                 num[d] += x;
             }
             else{
                 for(int i = ; i < dep[d].size(); i++){
                     add(dep[d][i], x);//暴力修改
                 }
             }
         }
         else{
             int x;
             scanf("%d", &x);
             LL ans = query(ed[x]) - query(st[x] - );//查询子树中属于第二类的节点的部分
             for(int i = ; i < large.size(); i++){
                 //查询所有第一类的层数中 属于这棵子树的节点 乘以盖层的修改值
                 ans += (upper_bound(dep[large[i]].begin(), dep[large[i]].end(), ed[x]) - lower_bound(dep[large[i]].begin(), dep[large[i]].end(), st[x])) * num[large[i]];
             }
             printf("%lld\n", ans);
         }
     }

     return ;
 }