[noip2016]天天爱跑步(主席树+lca)

恩。。在百度的第一页翻了翻，没有用主席树做的，于是打算水一篇blog；

天天爱跑步

首先有一个解题的关键；
将玩家的向上和向下分成两部分；

先定义几个变量，s是起点，t是终点，wi是每个观察员出现的时间，i是当前节点,d[]是节点深度；
通过手玩可以发现，当玩家向上走时能否被i观察到当且仅当d[s]=d[i]+w[i],向下走时能否被i 观察到当且仅当d[s]-d[lca(s,t)]*2=w[i]-d[i];

所以可以分开考虑向上走和向下走，将所有点经过的地方进行染色，例如考虑向上走，就在所有s到lca的路径上每个点的d[s]值对应的地方+1；

但是每个点开一个数组存所有染色结果是不现实的，考虑进行差分，在每个s或t点打上+1标记，在lca(s,t)的父亲节点打上-1标记；正常的差分操作是dfs一遍每个点都算好，但是这里每个点不可能都开这么大数组；

考虑对于一个点的dfs会返回什么结果？会将其子树内所有打的标记合起来；

这就和树上主席树很像了，求一个dfs序，按dfs序将每个点的标记插到当前的主席树内，最后求一个点子树的标记和时再差分一下就好；

最后不要忘记如果lca的地方可行会被重复计算，所以要减1；

还有中间需要一步离散化。。。总体复杂度还是nlogn，不过大常数妥妥垫底。。。

额还有，我懒所以lca用的倍增qwq

一个noip题就这样让我用数据结构水过去了。。。（学的多就是吼哇（逃

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<utility>
const int maxn=300005;
struct EDGE{
    int next,to;
}edge[maxn*2];
int etot=0,node[maxn];
void add(int x,int y){
    edge[++etot].next=node[x];
    edge[etot].to=y;
    node[x]=etot;
}
int d[maxn],dp[maxn][20];
int start[maxn],end[maxn],tot=0,too[maxn];
void dfs(int x,int fa){
    start[x]=++tot;
    too[tot]=x;
    dp[x][0]=fa;
    d[x]=d[fa]+1;
    for(int i=node[x];i;i=edge[i].next)if(edge[i].to!=fa)dfs(edge[i].to,x);
    end[x]=tot; 
}
std::vector<std::pair<int,int> >v[maxn][2];
int getlca(int x,int y){
    if(d[x]<d[y])std::swap(x,y);
    for(int i=19;i>=0;i--)if(d[dp[x][i]]>=d[y])x=dp[x][i];
    if(x==y)return x;
    for(int i=19;i>=0;i--)if(dp[x][i]!=dp[y][i])x=dp[x][i],y=dp[y][i];
    return dp[x][0];
} 
int n,m,ans[maxn];
int vtot=0,val[maxn*2];

int lc(int x){
    return std::lower_bound(val+1,val+vtot+1,x)-val;
}
struct NODE{
    int l,r,sum;
}t[maxn*40];
int ntot=0;
void insert(int l,int r,int &x,int y,int pos,int v){
    t[++ntot]=t[y],x=ntot,t[x].sum+=v;
    if(l==r)return;
    int mid=(l+r)>>1;
    if(pos<=mid)insert(l,mid,t[x].l,t[y].l,pos,v);
    else insert(mid+1,r,t[x].r,t[y].r,pos,v);
}
int query(int l,int r,int x,int pos){
    if(!x)return 0;
    if(l==r)return t[x].sum;
    int mid=(l+r)>>1;
    if(pos<=mid)return query(l,mid,t[x].l,pos);
    else return query(mid+1,r,t[x].r,pos);
}
int rt[maxn],w[maxn][2];
void solve(int c){
    ntot=0;
    rt[0]=0;
    for(int i=1;i<=n;i++){
        int now=too[i];
        rt[i]=rt[i-1];
        int len=v[now][c].size();
        for(int k=0;k<len;k++){
            insert(1,vtot,rt[i],rt[i],lc(v[now][c][k].first),v[now][c][k].second);
        }
    }
    for(int i=1;i<=n;i++){
        int nlc=lc(w[i][c]);
        if(val[nlc]!=w[i][c])continue;
        ans[i]+=query(1,vtot,rt[end[i]],nlc)-query(1,vtot,rt[start[i]-1],nlc);
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=2;i<=n;i++){
        int tp1,tp2;
        scanf("%d%d",&tp1,&tp2);
        add(tp1,tp2);
        add(tp2,tp1);
    }
    dfs(1,0);
    for(int k=1;k<20;k++)
    for(int i=1;i<=n;i++)dp[i][k]=dp[dp[i][k-1]][k-1];
    for(int i=1;i<=n;i++){
        int tp;
        scanf("%d",&tp);
        w[i][0]=d[i]+tp;
        w[i][1]=tp-d[i];
    } 
    for(int i=1;i<=m;i++){
        int ts,te;
        scanf("%d%d",&ts,&te);
        int lca=getlca(ts,te);
        #define mk(a,b) std::make_pair(a,b)
        v[ts][0].push_back(mk(d[ts],1)); 
        v[dp[lca][0]][0].push_back(mk(d[ts],-1));
        v[te][1].push_back(mk(d[ts]-d[lca]*2,1));
        v[dp[lca][0]][1].push_back(mk(d[ts]-d[lca]*2,-1));
        if(d[ts]==w[lca][0])ans[lca]--;
        val[++vtot]=d[ts];
        val[++vtot]=d[ts]-d[lca]*2;
    } 
    std::sort(val+1,val+vtot+1);
    vtot=std::unique(val+1,val+vtot+1)-val-1;
    solve(0);
    solve(1);
    for(int i=1;i<=n;i++)printf("%d ",ans[i]);
    return 0;
}