bzoj 3626: [LNOI2014]LCA 树链剖分

传送门：http://www.lydsy.com/JudgeOnline/problem.php?id=3626

题解

这道题感觉起来真的好难啊，果然是我太弱了吧TvT。
还是直接复制gconeice的题解吧（orz）

显然，暴力求解的复杂度是无法承受的。
考虑这样的一种暴力，我们把 z 到根上的点全部打标记，对于 l 到 r 之间的点，向上搜索到第一个有标记的点求出它的深度统计答案。观察到，深度其实就是上面有几个已标记了的点（包括自身）。所以，我们不妨把 z 到根的路径上的点全部 +1，对于 l 到 r 之间的点询问他们到根路径上的点权和。仔细观察上面的暴力不难发现，实际上这个操作具有叠加性，且可逆。也就是说我们可以对于 l 到 r 之间的点 i，将 i 到根的路径上的点全部 +1, 转而询问 z 到根的路径上的点（包括自身）的权值和就是这个询问的答案。把询问差分下，也就是用 [1, r] − [1, l − 1] 来计算答案，那么现在我们就有一个明显的解法。从 0 到 n − 1 依次插入点 i，即将 i 到根的路径上的点全部+1。离线询问答案即可。我们现在需要一个数据结构来维护路径加和路径求和，显然树链剖分或LCT 均可以完成这个任务。树链剖分的复杂度为 O((n + q)· log n · log n)，LCT的复杂度为 O((n + q)· log n)，均可以完成任务。至此，题目已经被我们完美解决。

写的非常详尽了，我再解释几句实现方法。
首先把询问离线，对于一个询问(l,r,z)，将l和r分别加入到两个结构体中并记录他们所在的位置，最终一起排序。
之后把链剖的dfs部分处理出来。
最后就是处理询问，因为询问时从小到大排好序的，之后就可以从小到大依次加点，每次加点从该点到根节点的权值+1，询问时求出从z到根节点的点权和即为答案。

code

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cctype>
#define LEN 1<<16
char getc()
{
    static char *S,*T,buf[LEN];
    if(S==T)
    {
        T=(S=buf)+fread(buf,1,LEN,stdin);
        if(S==T)
            return EOF;
    }
    return *S++;
}
int read()
{
    static char ch;
    static int D;
    while(!isdigit(ch=getc()));
    for(D=ch-'0';isdigit(ch=getc());)
        D=D*10+ch-'0';
    return D;
}
#define N 50010
#define ls rt<<1
#define rs rt<<1|1
#define mod 201314
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
using namespace std;
struct ss{int next,to;}Edge[N];
struct node{int p,id,flag;}a[N<<1];
struct name{int z,ans;}q[N];
int n,m,tot,qt,cnt;
int head[N];
int fa[N],son[N],size[N],dfn[N],top[N],w[N];
int f[N<<2],lazy[N<<2];

bool cmp(node x,node y)
{
    return x.p<y.p;
}

void add(int x,int y)
{
    Edge[++tot].next=head[x];
    Edge[tot].to=y;
    head[x]=tot;
}

void dfs1(int u,int deep)
{
    dfn[u]=deep,size[u]=1;
    for(int i=head[u];i;i=Edge[i].next)
    {
        int to=Edge[i].to;
        dfs1(to,deep+1);
        size[u]+=size[to];
        if(size[to]>size[son[u]])son[u]=to;
    }
}

void dfs2(int u,int tp)
{
    top[u]=tp,w[u]=++qt;
    if(!son[u])return ;
    dfs2(son[u],tp);
    for(int i=head[u];i;i=Edge[i].next)
    {
        int to=Edge[i].to;
        if(to==son[u])continue;
        dfs2(to,to);
    }
}

void PushUp(int rt)
{
    f[rt]=(f[ls]+f[rs])%mod;
}

void PushDown(int l,int r,int rt)
{
    if(!lazy[rt])return ;
    int mid=l+r>>1;
    f[ls]=(f[ls]+lazy[rt]*(mid-l+1))%mod,f[rs]=(f[rs]+lazy[rt]*(r-mid))%mod;
    lazy[ls]=(lazy[ls]+lazy[rt])%mod,lazy[rs]=(lazy[rs]+lazy[rt])%mod;
    lazy[rt]=0;
}

void updata(int l,int r,int rt,int L,int R)
{
    if(l>=L&&r<=R)
    {
        f[rt]=(f[rt]+r-l+1)%mod,lazy[rt]=(lazy[rt]+1)%mod;
        return ;
    }
    int mid=l+r>>1;
    PushDown(l,r,rt);
    if(mid>=L)updata(lson,L,R);
    if(mid<R)updata(rson,L,R);
    PushUp(rt);
}

void change(int x,int y)
{
    while(top[x]!=top[y])
    {
        updata(1,n,1,w[top[x]],w[x]);
        x=fa[top[x]];
    }
    updata(1,n,1,w[y],w[x]);
}

int query(int l,int r,int rt,int L,int R)
{
    if(l>=L&&r<=R)return f[rt];
    int mid=l+r>>1,ans=0;
    PushDown(l,r,rt);
    if(mid>=L)ans=(ans+query(lson,L,R))%mod;
    if(mid<R)ans=(ans+query(rson,L,R))%mod;
    return ans;
}

int ask(int x,int y)
{
    int ans=0;
    while(top[x]!=top[y])
    {
        ans=(ans+query(1,n,1,w[top[x]],w[x]))%mod;
        x=fa[top[x]];
    }
    ans=(ans+query(1,n,1,w[y],w[x]))%mod;
    return ans;
}

int main()
{
    n=read(),m=read();
    for(int i=2;i<=n;i++)
    {
        fa[i]=read()+1;
        add(fa[i],i);
    }
    dfs1(1,1),dfs2(1,1);
    for(int i=1;i<=m;i++)
    {
        int x=read()+1,y=read()+1,z=read()+1;
        a[++cnt].p=x-1,a[cnt].id=i,a[cnt].flag=-1;
        a[++cnt].p=y,a[cnt].id=i,a[cnt].flag=1;
        q[i].z=z;
    }
    sort(a+1,a+cnt+1,cmp);
    int tail=0;
    for(int i=1;i<=cnt;i++)
    {
        while(tail<a[i].p)
        {
            tail++;
            change(tail,1);
        }
        q[a[i].id].ans=((q[a[i].id].ans+a[i].flag*ask(q[a[i].id].z,1))%mod+mod)%mod;
    }
    for(int i=1;i<=m;i++)
        printf("%d\n",q[i].ans);
    return 0;
}