CodeForces 276E Little Girl and Problem on Trees（线段树区间更新）

题意：

给出一颗树，每次对树进行两种操作。
第一种操作：给节点v及距离节点v，d个单位长度以内的节点加x
第二种操作：询问节点v当前的值。
注意：给出的树中，除了节点1以为，其他节点的度都不会超过2。

解析：

有了上面这个条件后可以发现，这种树肯定是节点1拖着很多直链的。
看了网络上面的题解，理解了可以用两颗线段树来做这题。
一棵线段树来维护每层加了多少次，另外一棵线段树来维护每条链加了多少次。
首先，做一遍dfs序，求出所有节点的深度（根节点深度为0），以及每个节点的孩子节点的个数，并给每个节点编个号。
然后再建两颗线段树。
第一种操作的时候，如果节点v加上d之后不能到达节点1，则只对单条链进行操作；
如果能到达节点1，则说明深度为 [1,d−depth[v]] 的节点都能到达，维护深度的线段树，在 [1,d−depth[v]] 统一加上x，相当于区间更新，然后剩下一条链，然后再利用线段树维护这条链。

总结：

如果 v=1 时，直接更新 [1,d+1] 的深度，我错写成更新 [1,d] ，结果一直wa再46个用例，调试了好久，才debug出来。

my code

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#define ls (o<<1)
#define rs (o<<1|1)
#define lson ls, L, M
#define rson rs, M+1, R
#define pb push_back
using namespace std;
const int N = (int)1e5 + 10;
int n, m;
vector<int> G[N];

inline void addEdge(int u, int v) {
    G[u].pb(v);
}

struct Tree {
    int sumv[N<<2], addv[N<<2];

    void build(int o, int L, int R) {
        sumv[o] = addv[o] = 0;
        if(L == R) return ;
        int M = (L + R)/2;
        build(lson);
        build(rson);
    }

    int query(int o, int L, int R, int pos) {
        if(L == R) return sumv[o];
        pushDown(o, L, R);
        int M = (L + R)/2;
        if(pos <= M) return query(lson, pos);
        else return query(rson, pos);
    }

    inline void pushDown(int o, int L, int R) {
        if(addv[o]) {
            int M = (L + R)/2;
            addv[ls] += addv[o], addv[rs] += addv[o];
            sumv[ls] += addv[o] * (M - L + 1);
            sumv[rs] += addv[o] * (R - M);
            addv[o] = 0;
        }
    }

    inline void pushUp(int o) {
        sumv[o] = sumv[ls] + sumv[rs];
    }

    void modify(int o, int L, int R, int ql, int qr, int val) {
        if(ql <= L && R <= qr) {
            sumv[o] += val * (R - L + 1);
            addv[o] += val;
            return ;
        }
        pushDown(o, L, R);
        int M = (L + R)/2;
        if(ql <= M) modify(lson, ql, qr, val);
        if(qr > M) modify(rson, ql, qr, val);
        pushUp(o);
    }
} layer, chain;

int depth[N], son[N], id[N];
int dfs_clock;

void init() {
    for(int i = 1; i <= n; i++)
        G[i].clear();
    dfs_clock = 0;
    layer.build(1, 1, N);
    chain.build(1, 1, N);
}

void dfs(int u, int pre, int de) {
    id[u] = ++dfs_clock;
    depth[u] = de;
    son[u] = 0;
    for(int i = 0; i < G[u].size(); i++) {
        int v = G[u][i];
        if(pre == v) continue;
        dfs(v, u, de+1);
        son[u] = son[v] + 1;
    }
}

inline int query(int v) {
    return chain.query(1, 1, N, id[v]) + layer.query(1, 1, N, depth[v]+1);
}

void modify(int v, int val, int dist) {
    if(v == 1) {
        layer.modify(1, 1, N, 1, dist+1, val);
        return ;
    }
    int length = dist - depth[v];
    int ql, qr;
    if(length > 0) {
        layer.modify(1, 1, N, 1, length + 1, val);
        ql = id[v] + length - depth[v] + 1;
        qr = (dist > son[v]) ? (id[v] + son[v]) : (id[v] + dist);
        chain.modify(1, 1, N, ql, qr, val);
    }else {
        ql = id[v] - dist;
        qr = (dist > son[v]) ? (id[v] + son[v]) : (id[v] + dist);
        if(depth[v] - dist == 0) {
            chain.modify(1, 1, N, 1, 1, val);
            chain.modify(1, 1, N, ql+1, qr, val);
        }else {
            chain.modify(1, 1, N, ql, qr, val);
        }
    }
}

int main() {
    int u, v;
    int oper, x, d;
    while(~scanf("%d%d", &n, &m)) {
        init();
        for(int i = 0; i < n-1; i++) {
            scanf("%d%d", &u, &v);
            addEdge(u, v);
            addEdge(v, u);
        }
        dfs(1, -1, 0);
        for(int i = 0; i < m; i++) {
            scanf("%d", &oper);
            if(oper == 1) {
                scanf("%d", &v);
                printf("%d\n", query(v));
            }else {
                scanf("%d%d%d", &v, &x, &d);
                modify(v, x, d);
            }
        }
    }
    return 0;
}