NOIP 2016 天天爱跑步

我独立想只想出来了前80分的做法，不过貌似我的做法离正解比较远

测试点1~2

直接看每个点有多少玩家且这个点时间为0即可

测试点3~4

看每个点有多少个起点

测试点5

暴力模拟过程即可

测试点6~8

每个玩家在起点的点记录下起点和终点

然后搜每一个点，算出如果要跑到这点应该在的起点，然后再根据这个起点和终点来看

经不经过当前这个点

测试点9~12

要满足被经过则deep[i] = w[i]

那么关键是路径由没有过当前点

那么对每一个终点，把这个终点到根的路径的每个点的权值加1即可（用树上差分）

这样找每个观察员的时候就知道他被多少路径覆盖了

测试点13~16

可以通过w的值算出可以观察到的路径的长度

那么根据长度进行排序

对于每一个观察员，算出路径的长度

然后可以二分出当前长度的区间。

但是这个时候起点必须在观察员的子树内

那么我们可以记录dfs序，排序的时候长度为第一关键字，dfs序为第二关键字

那么就可以两次二分求左端点和右端点，就可以求出出符合条件的路径有多少了。

这个做法很骚，想了很久。

这就是我能独立想出的极限了。

看了下题解发现我貌似偏离正解比较远……

经过4个小时的奋战……

终于在看题解的情况下把这道题A掉了

AC掉了那一下感觉整个人都升华了

整个思路可以看http://www.cnblogs.com/bingdada/p/7744200.html

大致思路就是用一个桶来维护当前节点子树中起点的个数

然后对于一条路径拆成u->lca和lca->v上下两段来计算

然后遍历完记得删除路径的信息

细节巨多，代码里面有注释 

#include<bits/stdc++.h>
#define REP(i, a, b) for(register int i = (a); i < (b); i++)
#define _for(i, a, b) for(register int i = (a); i <= (b); i++)
using namespace std;

const int MAXN = 3e5 + 10;
const int MAXM = 20;

vector<int> v1[MAXN], v2[MAXN], v3[MAXN];
int w[MAXN], d[MAXN], num[MAXN], ans[MAXN], n, m;
int f[MAXN][MAXM + 5], buck[MAXN << 1];

struct Edge{ int to, next; };
Edge e[MAXN << 1];
int head[MAXN], tot;

void AddEdge(int from, int to)
{
    e[tot] = Edge{to, head[from]};
    head[from] = tot++;
}

void read(int& x)
{
    int f = 1; x = 0; char ch = getchar();
    while(!isdigit(ch)) { if(ch == '-') f = -1; ch = getchar(); }
    while(isdigit(ch)) { x = x * 10 + ch - '0'; ch = getchar(); }
    x *= f;
}

void dfs(int u, int fa)
{
    for(int i = head[u]; ~i; i = e[i].next)
    {
        int v = e[i].to;
        if(v == fa) continue;
        d[v] = d[u] + 1;
        f[v][0] = u;
        dfs(v, u);
    }
}

void get_lca()
{
    f[1][0] = 1; //记住跟节点的父亲是自己，不然会WA 
    dfs(1, -1); //因为如果两点的一端有根节点的话，lca是根节点，也就是最后跳到自己 
    _for(j, 1, MAXM)
        _for(i, 1, n)
            f[i][j] = f[f[i][j-1]][j-1];
}

int LCA(int u, int v)
{
    if(d[u] < d[v]) swap(u, v);
    for(int j = MAXM; j >= 0; j--) //j从大到小 
        if(d[f[u][j]] >= d[v])
            u = f[u][j];
    if(u == v) return u;
    for(int j = MAXM; j >= 0; j--)
        if(f[u][j] != f[v][j])
            u = f[u][j], v = f[v][j];
    return f[u][0];
}

void dfs1(int u, int fa)
{
    int pre = buck[w[u] + d[u] + MAXN];  //记住buck里面的下标是深度 
    for(int i = head[u]; ~i; i = e[i].next)
    {
        int v = e[i].to;
        if(v == fa) continue;
        dfs1(v, u);
    }
    buck[d[u] + MAXN] += num[u]; //顺序不能错，先更新该点的贡献，然后统计答案，然后删除 
    ans[u] += buck[w[u] + d[u] + MAXN] - pre; //注意这里加的是差值 
    REP(i, 0, v1[u].size()) //遍历完之后对祖先就没有贡献了 
        buck[d[v1[u][i]] + MAXN]--; 
}

void dfs2(int u, int fa)
{
    int pre = buck[w[u] - d[u] + MAXN]; //防止负数下标+MAXN 
    for(int i = head[u]; ~i; i = e[i].next)
    {
        int v = e[i].to;
        if(v == fa) continue;
        dfs2(v, u);
    }
    REP(i, 0, v2[u].size())
        buck[v2[u][i] + MAXN]++;
    ans[u] += buck[w[u] - d[u] + MAXN] - pre;    
    REP(i, 0, v3[u].size()) //注意这里v3的下标是lca 
        buck[v3[u][i] + MAXN]--;
}

int main()
{
    memset(head, -1, sizeof(head)); tot = 0;
    scanf("%d%d", &n, &m);
    REP(i, 1, n)
    {
        int u, v; read(u), read(v);
        AddEdge(u, v); AddEdge(v, u);
    }
    _for(i, 1, n) read(w[i]);
    
    get_lca();
    _for(i, 1, m)
    {
        int u, v; read(u), read(v);
        int lca = LCA(u, v);
        int dis = d[u] + d[v] - 2 * d[lca];
        
        num[u]++;
        v1[lca].push_back(u);
        v2[v].push_back(dis - d[v]);
        v3[lca].push_back(dis - d[v]);  
        if(w[lca] + d[lca] == d[u]) ans[lca]--; //去重 
    }
    
    dfs1(1, -1);
    dfs2(1, -1);
    _for(i, 1, n) printf("%d ", ans[i]);
    puts("");
    
    return 0;
}