NOIP2016 天天爱跑步（树上差分）

题意

有一棵$n$个点的树。

有$m$个人，第$i$个人从$x_i$开始，以每秒1条边的速度向$y_i$跑。

每个点有一个观察员在第$t_i$秒观察，求每个点的观察员能观察到几个人。

思路

首先把一条路拆成向上和向下的两条，分别考虑。

向上的路径，如果能对$x$产生贡献，必须满足：

1.$st$在$x$的子树里
2.$ed$在$x$的外部（实际上就是在$x$到根的链上）
3.$dpt[st]=dpt[x]+t[x]$
($dpt$表示深度，$st$表示路径的起点，$ed$表示终点)

向下的路径，如果能对$x$产生贡献，必须满足：

1.$ed$在$x$的子树里
2.$st$在$x$的外部（实际上就是在$x$到根的链上）
3.$dpt[st]-t1[st]=dpt[x]-t[x]$
($t1$表示出发时间，因为可能接在向上的路径之后)

发现条件有点多，比较难处理。首先我想的是线段树合并（并没有A掉，而且现在还不知道错在哪里）。

每个点一棵权值线段树，存向上路径的$dpt[st]$数量和向下路径的$dpt[st]-t1[st]$数量，在较深的点+1，在较浅的点的上方-1。动态开点，时间空间复杂度其实都没有问题，但是又RE又WA不知道为什么。

然后此时看到了题解中的差分+桶。

其实桶比线段树多存的就是较深的点的DFN在当前点之前，较浅的点却还没有被退栈的路径，换句话说就是在当前子树之外，却还在桶内的点。最开始因为不知道如何处理这个所以没有继续想下去。

然后此时又在茫茫题解中看到了CHY神仙的题解。

只要在当前节点刚刚入栈的时候记录一下当前桶里的值，后来再减掉就好了。

太精辟了喂。可能这就是神仙吧。非常简单但是很厉害。

代码

#include<bits/stdc++.h>
#define pb push_back
using namespace std;
const int N = 3e5+10;
const int M = N<<1;
const int E = 20;
int n, m, tim[N];
struct G{
    int e, h[N], nxt[M], p[M];
    void init(){
        e = 0;
        memset(h, 0, sizeof(h));
    }
    void add(int u, int v){
        ++ e;
        nxt[e] = h[u];
        p[e] = v;
        h[u] = e;
    }
}g;
int dpt[N], f[N][E];
vector<int> st1[N], ed1[N], st2[N], ed2[N];
int ton1[N<<1], ton2[N<<1], ans[N];

void Dfs(int u, int fa)
{
    dpt[u] = dpt[fa]+1;
    f[u][0] = fa;
        g.add(x, y);
        g.add(y, x);
    for (int i = 1; i < E; ++ i)
        f[u][i] = f[f[u][i-1]][i-1];
    for (int i = g.h[u]; i; i = g.nxt[i]){
        int v = g.p[i];
        if (v == fa) continue;
        Dfs(v, u);
    }
}

int Lca(int x, int y)
{
    if (dpt[x] < dpt[y]) swap(x, y);
    for (int i = E-1; i >= 0; -- i)
        if (dpt[f[x][i]] >= dpt[y])
            x = f[x][i];
    if (x == y) return x;
    for (int i = E-1; i >= 0; -- i)
        if (f[x][i] != f[y][i])
            x = f[x][i], y = f[y][i];
    return f[x][0];
}

int Son(int x, int y)
{
    if (x == y) return -1;
    for (int i = E-1; i >= 0; -- i)
        if (dpt[f[x][i]] > dpt[y])
            x = f[x][i];
    return x;
}

void Dfs1(int u, int fa)
{
    int tmp = ton1[dpt[u]+tim[u]]+ton2[dpt[u]-tim[u]+n];
    for (int i = 0, ub = st1[u].size(); i < ub; ++ i)
        ++ ton1[st1[u][i]];
    for (int i = 0, ub = st2[u].size(); i < ub; ++ i)
        ++ ton2[st2[u][i]];
    for (int i = g.h[u]; i; i = g.nxt[i]){
        int v = g.p[i];
        if (v == fa) continue;
        Dfs1(v, u);
    }
    ans[u] = ton1[dpt[u]+tim[u]]+ton2[dpt[u]-tim[u]+n]-tmp;
    for (int i = 0, ub = ed1[u].size(); i < ub; ++ i)
        -- ton1[ed1[u][i]];
    for (int i = 0, ub = ed2[u].size(); i < ub; ++ i)
        -- ton2[ed2[u][i]];
}

int main()
{
    scanf("%d%d", &n, &m);
    g.init();
    for (int i = 1; i < n; ++ i){
        int x, y;
        scanf("%d%d", &x, &y);
        g.add(x, y);
        g.add(y, x);
    }

    dpt[0] = -1;
    Dfs(1, 0); 

    for (int i = 1; i <= n; ++ i)
        scanf("%d", &tim[i]);
    for (int i = 1; i <= m; ++ i){
        int x, y, z, w;
        scanf("%d%d", &x, &y);
        z = Lca(x, y);
        w = Son(y, z);
        st1[x].pb(dpt[x]);
        ed1[z].pb(dpt[x]);
        if (w != -1){
            st2[y].pb(dpt[w]-(dpt[x]-dpt[z]+1)+n);
            ed2[w].pb(dpt[w]-(dpt[x]-dpt[z]+1)+n);
        }
    }

    memset(ans, 0, sizeof(ans));
    memset(ton1, 0, sizeof(ton1));
    memset(ton2, 0, sizeof(ton2));
    Dfs1(1, 0);
    for (int i = 1; i <= n; ++ i)
        printf("%d ", ans[i]);
    return 0;
}