ACM-ICPC 2018 沈阳赛区网络预赛 J Ka Chang（树分块）

思路

因为不同深度的节点数量不同，数量少的节点，可以考虑直接进行单点更新，对于数量多的节点，可以直接记录这一层增加的值，查询的时候，看每一层有多少个节点，最后乘上增加的值就行了。

具体实现

先设定一个belong[maxn]数组，用于放同一层的节点的dfs序（这样做是为了可以在树状数组上进行单点更新，同一层的dfs序虽然不是连续的，但是也符合从小到大的顺序）。其次设定一个值block=1<<10，当节点数量大于block时，将这一层的编号记录下来，用一个large来储存，这样，当查询时，只要在large里遍历这些数量多的层，看每一层有多少个我们需要的节点就行了。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=6e5+7;
const int N=1e5+9;
int n,q;
struct BIT
{
    int n;
    ll bit[N];
    void init(int n)
    {
        this->n = n + 1;
        for (int i = 0; i < n; i++) bit[i] = 0;
    }
    void update(int x, ll v)
    {
        for (; x < n; x += x & -x) bit[x] += v;
    }
    ll query(int x)
    {
        ll ret = 0;
        for (; x; x -= x & -x) ret += bit[x];
        return ret;
    }
} bit;
const int block=1<<10;
vector<int> g[maxn],belong[maxn],large;
int depth[maxn],in[maxn],out[maxn];
ll s[maxn];
int clk;
void dfs(int u, int d)
{
    in[u] = ++clk;
    belong[d].push_back(in[u]);
    for (auto& v : g[u])
    {
        depth[v] = depth[u] + 1;
        dfs(v, d + 1);
    }
    out[u] = clk;
}

int main()
{
    #ifndef ONLINE_JUDGE
        freopen("in.txt","r",stdin);
        freopen("out.txt","w",stdout);
    #endif
    scanf("%d%d",&n,&q);
    bit.init(n);
    clk=0;
    memset(s,0,sizeof(s));
    for(int i=1,x,y;i<n;i++)
    {
        scanf("%d%d",&x,&y);
        g[x].push_back(y);
    }
    dfs(1,0);
    for(int i=0;i<=n;i++)
    {
        if(belong[i].size()>block)
        {
            large.push_back(i);
        }
    }
    while(q--)
    {
        int op;
        scanf("%d",&op);
        if(op==1)
        {
            int x,v;
            scanf("%d%d",&x,&v);
            if(belong[x].size()<= block)
            {
                for(auto &t: belong[x])
                {
                    bit.update(t,v);
                }
            }
            else
            {
                s[x]+=v;
            }
        }
        else
        {
            int x;
            scanf("%d",&x);
            int l=in[x],r=out[x];
            ll ans=0;
            ans=bit.query(r)-bit.query(l-1);
            for(auto &t: large)
            {
                ans+=((upper_bound(belong[t].begin(),belong[t].end(),r))-\
                (lower_bound(belong[t].begin(),belong[t].end(),l)))*s[t];
            }
            printf("%lld\n",ans);
        }
    }
    return 0;
}