【BZOJ 3626】 [LNOI2014]LCA【在线+主席树+树剖】

题目链接：

　　TP

题解：

　　  可能是我比较纱布，看不懂题解,只好自己想了……

　　先附一个离线版本题解[Ivan]

　　我们考虑对于询问区间是可以差分的，然而这并没有什么卵用，然后考虑怎么统计答案。

　　首先LCA一定是z的祖先（这里说的祖先包括自己，以下祖先均为此概念）节点，也就是是说我们只要计算出每个祖先节点的贡献就可以了，再考虑每个祖先的贡献如何计算。

　　我们发现对于深度其实是该点到root的路径点数，所以我们可以这样想，我们询问z的祖先的答案，就是在计算有对于给定区间有多少个点经过了z的祖先。

　　那么思路到这里就很清晰了，我们先把每个点到root的路径上的点权都加1，在询问的时候用历史版本做差分即可，那么带永久化标记的主席树+树剖啊QwQ。

　　至于时间复杂度，有理有据的$O(nlog^2)$。

代码：

　　

#define Troy 

#include <bits/stdc++.h>

using namespace std;

inline int read(){
    int s=0,k=1;char ch=getchar();
    while(ch<'0'|ch>'9')    ch=='-'?k=-1:0,ch=getchar();
    while(ch>47&ch<='9')    s=s*10+(ch^48),ch=getchar();
    return s*k;
}

const int N=5e4+5,mod=201314;

int n,Q;

struct edges{
    int v;edges *last;
}edge[N<<1],*head[N];int cnt;

inline void push(int u,int v){
    edge[++cnt]=(edges){v,head[u]};head[u]=edge+cnt;
}

class Persistent_Segment_tree{
public:
    inline void add(int pos,int l,int r){
        add(root[pos-1],root[pos],1,n,l,r);
    }
    inline int query(int last,int pos,int l,int r){
        return query(root[last-1],root[pos],1,n,l,r,0);
    }
    inline void build(){
        root[0]=tree;
        root[0]->lc=tree;
        root[0]->rc=tree;
        cnt_tree=1;
    }
    inline int  out(){
        return cnt_tree;
    }
private:
    struct Tree{
        Tree *lc,*rc;
        int sign_per,val;
        Tree(){sign_per=val=0;lc=rc=NULL;}
    }tree[N<<7],*root[N<<5];int cnt_tree;
    inline void add(Tree *p,Tree *&u,int l,int r,int x,int y){
        u=tree+cnt_tree;cnt_tree++;
        *u=*p;
        u->val+=y-x+1;
        u->val%=mod;
        if(x<=l&&r<=y){;u->sign_per++;return;}
        int mid=l+r>>1;
        if(x>mid)   add(p->rc,u->rc,mid+1,r,x,y);
        else    if(y<=mid)  add(p->lc,u->lc,l,mid,x,y);
        else    add(p->lc,u->lc,l,mid,x,mid),add(p->rc,u->rc,mid+1,r,mid+1,y);
    }
    inline int query(Tree *p,Tree *u,int l,int r,int x,int y,int sign_p){
        if(x<=l&&r<=y){
            return (sign_p*1ll*(r-l+1)%mod+u->val-p->val)%201314+mod;
        }
        int mid=l+r>>1,ret=0;
        if(y>mid)   ret+=query(p->rc,u->rc,mid+1,r,x,y,sign_p+u->sign_per-p->sign_per);
        if(x<=mid)  ret+=query(p->lc,u->lc,l,mid,x, y, sign_p+u->sign_per-p->sign_per);
        return ret%201314;
    }
}war;

int fa[N],g[N],size[N],heavy[N],tid[N],idx,deep[N],L[N],R[N];

inline void dfs(int x){
    size[x]=1;
    for(edges *i=head[x];i;i=i->last)   if(i->v!=fa[x]){
        deep[i->v]=deep[x]+1,fa[i->v]=x,dfs(i->v);
        size[x]+=size[i->v];
        if(size[heavy[x]]<size[i->v])
            heavy[x]=i->v;
    }
}

inline void dfs(int x,int grand){
    tid[x]=++idx;
    g[x]=grand;
    if(heavy[x]){
        dfs(heavy[x],grand);
        for(edges *i=head[x];i;i=i->last)   if(i->v!=fa[x]&&i->v!=heavy[x]){
            dfs(i->v,i->v);
        }
    }
}

inline void add(int x){
    L[x]=idx+1;
    int t=x;
    while(g[x]!=1){
        ++idx;
        war.add(idx,tid[g[x]],tid[x]);
        x=fa[g[x]];
    }
    ++idx,war.add(idx,tid[1],tid[x]);
    R[t]=idx;
}

inline int query(int x,int l,int r){
    int ret=0;
    while(g[x]!=1){
        (ret+=war.query(L[l],R[r],tid[g[x]],tid[x]))%=mod;
        x=fa[g[x]];
    }        
    ret+=war.query(L[l],R[r],tid[1],tid[x]);
    return ret%mod;
}

int main(){
    n=read(),Q=read();
    for(int i=2;i<=n;++i){
        int x=read()+1;
        push(x,i),push(i,x);
    }
    dfs(1);dfs(1,1);idx=0;
    war.build();
    for(int i=1;i<=n;++i){
        add(i);
    }
    while(Q--){
        int l=read()+1,r=read()+1,z=read()+1;
        printf("%d\n",(query(z,l,r)%mod+mod)%mod);
    }
}