bzoj 4719: [Noip2016]天天爱跑步 线段树合并

题意

有一棵n个节点的树，每条边权为1，每个节点都会在某一个时间出现观察员且只会出现一次。现有m个玩家，给定每个玩家的起点，然后每个玩家会在时刻0从起点出发，沿着唯一的路径走向终点。问每个观察员分别可以看到多少个玩家。
n,m<=300000

分析

话说这真的是NOIPd1t2的难度吗？这不科学啊233333

首先必须要想到的是对于每一个玩家的路径可以拆成两条，一条从起点到lca，另一条从lca往下一个节点到终点（本蒟蒻比赛的时候就没有想到QAQ），然后就可以发现一个规律，就是第一条路径上的每个节点的到达时间+深度的值是固定的，第二条路径上的每个节点的深度-到达时间的值是固定的，那么我们就可以把第一条路径和第二条路径分开处理，在起点处打一个+1标记，在终点处打一个-1标记，那么就可以进行深度优先搜索，当一个节点的子节点处理完后，就可以从该节点的子树得到该节点的答案。但很显然这东西不好维护，于是我强行借鉴了一波栋爷的方法：线段树合并来维护答案。
总复杂度$O(nlogn)$

一开始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;
}