【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=,k=;char ch=getchar();
     while(ch<''|ch>'')    ch=='-'?k=-:,ch=getchar();
     while(ch>&ch<='')    s=s*+(ch^),ch=getchar();
     return s*k;
 }

 const int N=5e4+,mod=;

 int n,Q;

 struct edges{
     int v;edges *last;
 }edge[N<<],*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-],root[pos],,n,l,r);
     }
     inline int query(int last,int pos,int l,int r){
         return query(root[last-],root[pos],,n,l,r,);
     }
     inline void build(){
         root[]=tree;
         root[]->lc=tree;
         root[]->rc=tree;
         cnt_tree=;
     }
     inline int  out(){
         return cnt_tree;
     }
 private:
     struct Tree{
         Tree *lc,*rc;
         int sign_per,val;
         Tree(){sign_per=val=;lc=rc=NULL;}
     }tree[N<<],*root[N<<];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+;
         u->val%=mod;
         if(x<=l&&r<=y){;u->sign_per++;return;}
         int mid=l+r>>;
         if(x>mid)   add(p->rc,u->rc,mid+,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+,r,mid+,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+)%mod+u->val-p->val)%+mod;
         }
         int mid=l+r>>,ret=;
         if(y>mid)   ret+=query(p->rc,u->rc,mid+,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%;
     }
 }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]=;
     for(edges *i=head[x];i;i=i->last)   if(i->v!=fa[x]){
         deep[i->v]=deep[x]+,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+;
     int t=x;
     while(g[x]!=){
         ++idx;
         war.add(idx,tid[g[x]],tid[x]);
         x=fa[g[x]];
     }
     ++idx,war.add(idx,tid[],tid[x]);
     R[t]=idx;
 }

 inline int query(int x,int l,int r){
     int ret=;
     while(g[x]!=){
         (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[],tid[x]);
     return ret%mod;
 }

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