ACM-ICPC 2018 沈阳赛区网络预赛 J. Ka Chang(树状数组+分块)

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

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

1 L X: Increase points by X of all nodes whose depth equals L ( the depth of the root is zero ). (x≤10⁸)

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

Input
Just one case.

The first lines contain two integer, N,Q(N≤10⁵,Q≤10⁵).

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

The next Q lines are queries.

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

样例输入
3 3
1 2
2 3
1 1 1
2 1
2 3

样例输出
1
0

题意

给你一颗以1为根节点的数，有两个操作

1.层数为L的节点增加X

2.查询以X为根节点的子树总权和

题解

操作2很容易想到dfs维护树状数组

对于操作1，可以把层数按sqrt(n)分块，对于层数点数<=block的直接暴力更新，对于>block先保存进数组ans，查询的时候二分左右区间可以知道根的节点数，再乘ans，这样可以把单次操作的复杂度固定在sqrt(n)范围内

代码

#include<bits/stdc++.h>
using namespace std;

#define LL long long

const int maxn=1e5+5;
int s[maxn],e[maxn],tot,n;
LL sum[maxn],ans[maxn];
vector<int>G[maxn],deep[maxn],q;
void dfs(int u,int fa,int d)
{
    s[u]=++tot;
    deep[d].push_back(s[u]);
    for(auto v:G[u])
    {
        if(v==fa)continue;
        dfs(v,u,d+1);
    }
    e[u]=tot;
}
int lowbit(int x)
{
    return x&(-x);
}
void update(int x,int add)
{
    for(int i=x;i<=n;i+=lowbit(i))
        sum[i]+=add;
}
LL query(int x)
{
    LL ans=0;
    for(int i=x;i>0;i-=lowbit(i))
        ans+=sum[i];
    return ans;
}
int main()
{
    int Q,op,L,x,u,v;
    scanf("%d%d",&n,&Q);
    int block=sqrt(n);
    for(int i=1;i<n;i++)
    {
        scanf("%d%d",&u,&v);
        G[u].push_back(v);
        G[v].push_back(u);
    }
    dfs(1,-1,0);
    for(int i=0;i<n;i++)
        if(deep[i].size()>block)q.push_back(i);
    for(int i=0;i<Q;i++)
    {
        scanf("%d",&op);
        if(op==1)
        {
            scanf("%d%d",&L,&x);
            if(deep[L].size()>block)ans[L]+=x;
            else
            {
                for(auto X:deep[L])
                    update(X,x);
            }
        }
        else
        {
            scanf("%d",&x);
            LL res=query(e[x])-query(s[x]-1);
            for(auto pos:q)
                res+=ans[pos]*(upper_bound(deep[pos].begin(),deep[pos].end(),e[x])-lower_bound(deep[pos].begin(),deep[pos].end(),s[x]));
            printf("%lld\n",res);
        }
    }
    return 0;
}