題意

有一棵n個節點的樹，每條邊權為1，每個節點都會在某一個時間出現觀察員且只會出現一次。現有m個玩家，給定每個玩家的起點，然後每個玩家會在時刻0從起點出發，沿著唯一的路徑走向終點。問每個觀察員分別可以看到多少個玩家。
n,m<=300000

分析

話說這真的是NOIPd1t2的難度嗎？這不科學啊233333

首先必須要想到的是對於每一個玩家的路徑可以拆成兩條，一條從起點到lca，另一條從lca往下一個節點到終點（本蒟蒻比賽的時候就沒有想到QAQ），然後就可以發現一個規律，就是第一條路徑上的每個節點的到達時間+深度的值是固定的，第二條路徑上的每個節點的深度-到達時間的值是固定的，那麼我們就可以把第一條路徑和第二條路徑分開處理，在起點處打一個+1標記，在終點處打一個-1標記，那麼就可以進行深度優先搜尋，當一個節點的子節點處理完後，就可以從該節點的子樹得到該節點的答案。但很顯然這東西不好維護，於是我強行借鑑了一波棟爺的方法：線段樹合併來維護答案。
總複雜度O

一開始WA是因為在合併操作時沒有返回x，第二次是因為線段樹範圍開小了……

在bzoj上面跑了10s+，再次墊底，不過貌似比crazy爺的程式跑得快，然後在本校的OJ上面跑就T了23333

程式碼

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define N 300005
using namespace std;

int n,m,cnt,tot,last[N],ls[N],ans[N],tim[N],fa[N][30
 
],dep[N],sz,root1[N],root2[N];
struct edge{int to,next;}e[N*2];
struct query{int dep,val,op,next;}q[N*4];
struct tree{int l,r,s;}t[N*120];

int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0'
 
;ch=getchar();}
    return x*f;
}

void addedge(int u,int v)
{
    e[++cnt].to=v;e[cnt].next=last[u];last[u]=cnt;
    e[++cnt].to=u;e[cnt].next=last[v];last[v]=cnt;
}

void ins(int x,int dep,int op,int val)
{
    q[++tot].dep=dep;q[tot].op=op;q[tot].val=val;q[tot].next=ls[x];ls[x]=tot;
}

void dfs1(int x)
{
    dep[x]=dep[fa[x][0]]+1;
    for (int i=1;i<=20;i++)
        fa[x][i]=fa[fa[x][i-1]][i-1];
    for (int i=last[x];i;i=e[i].next)
    {
        if (e[i].to==fa[x][0]) continue;
        fa[e[i].to][0]=x;
        dfs1(e[i].to);
    }
}

int getlca(int x,int y)
{
    if (dep[x]<dep[y]) swap(x,y);
    for (int i=20;i>=0;i--)
        if (dep[fa[x][i]]>=dep[y]) x=fa[x][i];
    if (x==y) return x;
    for (int i=20;i>=0;i--)
        if (fa[x][i]!=fa[y][i])
        {
            x=fa[x][i];y=fa[y][i];
        }
    return fa[x][0];
}

int getson(int x,int y)
{
    if (dep[x]<dep[y]) swap(x,y);
    for (int i=20;i>=0;i--)
        if (dep[fa[x][i]]>dep[y]) x=fa[x][i];
    return x;
}

void ins(int &d,int l,int r,int x,int y)
{
    if (!d) d=++sz;
    t[d].s+=y;
    if (l==r) return;
    int mid=(l+r)/2;
    if (x<=mid) ins(t[d].l,l,mid,x,y);
    else ins(t[d].r,mid+1,r,x,y);
}

int find(int d,int l,int r,int x)
{
    if (l==r||!d) return t[d].s;
    int mid=(l+r)/2;
    if (x<=mid) return find(t[d].l,l,mid,x);
    else return find(t[d].r,mid+1,r,x);
}

int merge(int x,int y)
{
    if (!x) return y;
    if (!y) return x;
    t[x].s+=t[y].s;
    t[x].l=merge(t[x].l,t[y].l);
    t[x].r=merge(t[x].r,t[y].r);
    return x;
}

void dfs2(int x)
{
    for (int i=last[x];i;i=e[i].next)
    {
        if (e[i].to==fa[x][0]) continue;
        dfs2(e[i].to);
        root1[x]=merge(root1[x],root1[e[i].to]);
        root2[x]=merge(root2[x],root2[e[i].to]);
    }
    for (int i=ls[x];i;i=q[i].next)
        if (q[i].val==1)
        {
            if (q[i].op==1) ins(root1[x],1,n*3,q[i].dep,1);
            else ins(root2[x],1,n*3,q[i].dep,1);
        }
    ans[x]=find(root1[x],1,n*3,dep[x]+tim[x]+n)+find(root2[x],1,n*3,dep[x]-tim[x]+n);
    for (int i=ls[x];i;i=q[i].next)
        if (q[i].val==-1)
        {
            if (q[i].op==1) ins(root1[x],1,n*3,q[i].dep,-1);
            else ins(root2[x],1,n*3,q[i].dep,-1);
        }
}

int main()
{
    freopen("4719.in","r",stdin);
    //freopen("test.out","w",stdout);
    n=read();m=read();
    for (int i=1;i<n;i++)
    {
        int x=read(),y=read();
        addedge(x,y);
    }
    dfs1(1);
    for (int i=1;i<=n;i++)
        tim[i]=read();
    for (int i=1;i<=m;i++)
    {
        int x=read(),y=read(),lca=getlca(x,y);
        ins(x,dep[x]+n,1,1);
        ins(lca,dep[x]+n,1,-1);
        if (y!=lca)
        {
            int sy=getson(lca,y);
            ins(y,dep[y]-dep[x]-dep[y]+dep[lca]*2+n,2,1);
            ins(sy,dep[y]-dep[x]-dep[y]+dep[lca]*2+n,2,-1);
        }
    }
    dfs2(1);
    for (int i=1;i<n;i++)
        printf("%d ",ans[i]);
    cout<<ans[n];
    return 0;
}