BZOJ 3626 [LNOI2014]LCA：树剖 + 差分 + 离线【将深度转化成点权之和】

题目链接：http://www.lydsy.com/JudgeOnline/problem.php?id=3626

题意：

　　给出一个n个节点的有根树（编号为0到n-1，根节点为0，n <= 50000）。

　　一个点的深度定义为这个节点到根的距离+1。

　　设dep[i]表示点i的深度，LCA(i,j)表示i与j的最近公共祖先。

　　有q次询问，每次询问给出l,r,z，求∑ dep[LCA(i,z)] (l<=i<=r)。

　　（即，求在[l,r]区间内的每个节点i与z的最近公共祖先的深度之和）

题解：

　　假设有一棵所有点都为0的树。

　　如果将x到root路径上的点都+1，则dep[LCA(x,y)] = y到root路径上的点权之和，且这个操作具有叠加性。（树剖）

　　所以对于询问query(l to r) = query(r) - query(l-1)。（差分）

　　显然，只需要求出在询问中有的l和r的query。

　　所以依次枚举节点i = 0 to n-1，将i到root的路径+1，如果i是某一些询问的l或r，则记录相应的query(z)。（离线）

　　总复杂度O((n+q)*logn*logn)

AC Code:

 #include <iostream>
 #include <stdio.h>
 #include <string.h>
 #include <vector>
 #define MAX_N 200005
 #define MAX_M 50005
 #define MOD 201314

 using namespace std;

 struct Query
 {
     int ver;
     int id;
     int dr;
     Query(int _ver,int _id,int _dr)
     {
         ver=_ver;
         id=_id;
         dr=_dr;
     }
     Query(){};
 };

 int n,m;
 int tot=;
 int cnt=;
 int l[MAX_M];
 int r[MAX_M];
 int z[MAX_M];
 int dat[MAX_N];
 int lazy[MAX_N];
 int lson[MAX_N];
 int rson[MAX_N];
 int par[MAX_N];
 int dep[MAX_N];
 int siz[MAX_N];
 int tp[MAX_N];
 int son[MAX_N];
 int dfsx[MAX_N];
 int ans[MAX_M][];
 vector<int> edge[MAX_N];
 vector<Query> q[MAX_M];

 inline int mod(int x)
 {
     return (x%MOD+MOD)%MOD;
 }

 int build(int l,int r)
 {
     int rt=++tot;
     dat[rt]=lazy[rt]=;
     lson[rt]=rson[rt]=;
     if(l<r)
     {
         int mid=(l+r)>>;
         lson[rt]=build(l,mid);
         rson[rt]=build(mid+,r);
     }
     return rt;
 }

 void push_down(int k,int len)
 {
     if(lazy[k])
     {
         if(lson[k])
         {
             dat[lson[k]]=mod(dat[lson[k]]+lazy[k]*(len-(len>>)));
             lazy[lson[k]]=mod(lazy[lson[k]]+lazy[k]);
         }
         if(rson[k])
         {
             dat[rson[k]]=mod(dat[rson[k]]+lazy[k]*(len>>));
             lazy[rson[k]]=mod(lazy[rson[k]]+lazy[k]);
         }
         lazy[k]=;
     }
 }

 void push_up(int k)
 {
     dat[k]=;
     if(lson[k]) dat[k]=mod(dat[k]+dat[lson[k]]);
     if(rson[k]) dat[k]=mod(dat[k]+dat[rson[k]]);
 }

 void update(int a,int b,int k,int l,int r,int x)
 {
     if(a<=l && r<=b)
     {
         dat[k]=mod(dat[k]+(r-l+)*x);
         lazy[k]=mod(lazy[k]+x);
         return;
     }
     if(r<a || b<l) return;
     push_down(k,r-l+);
     int mid=(l+r)>>;
     update(a,b,lson[k],l,mid,x);
     update(a,b,rson[k],mid+,r,x);
     push_up(k);
 }

 int query(int a,int b,int k,int l,int r)
 {
     if(a<=l && r<=b) return dat[k];
     if(r<a || b<l) return ;
     push_down(k,r-l+);
     int mid=(l+r)>>;
     int v1=query(a,b,lson[k],l,mid);
     int v2=query(a,b,rson[k],mid+,r);
     return mod(v1+v2);
 }

 void dfs1(int now,int d)
 {
     dep[now]=d;
     siz[now]=;
     for(int i=;i<edge[now].size();i++)
     {
         int temp=edge[now][i];
         if(temp!=par[now])
         {
             dfs1(temp,d+);
             siz[now]+=siz[temp];
         }
     }
 }

 void dfs2(int now,int anc)
 {
     tp[now]=anc;
     son[now]=-;
     dfsx[now]=++cnt;
     for(int i=;i<edge[now].size();i++)
     {
         int temp=edge[now][i];
         if((son[now]==- || siz[temp]>siz[son[now]]) && temp!=par[now])
         {
             son[now]=temp;
         }
     }
     if(son[now]!=-) dfs2(son[now],anc);
     for(int i=;i<edge[now].size();i++)
     {
         int temp=edge[now][i];
         if(temp!=par[now] && temp!=son[now]) dfs2(temp,temp);
     }
 }

 void update_chain(int a,int x)
 {
     while(tp[a]!=)
     {
         update(dfsx[tp[a]],dfsx[a],,,n,x);
         a=par[tp[a]];
     }
     update(,dfsx[a],,,n,x);
 }

 int query_chain(int a)
 {
     int sum=;
     while(tp[a]!=)
     {
         sum=mod(sum+query(dfsx[tp[a]],dfsx[a],,,n));
         a=par[tp[a]];
     }
     sum=mod(sum+query(,dfsx[a],,,n));
     return sum;
 }

 void read()
 {
     scanf("%d%d",&n,&m);
     for(int i=;i<n;i++)
     {
         scanf("%d",&par[i]);
         edge[i].push_back(par[i]);
         edge[par[i]].push_back(i);
     }
 }

 void solve()
 {
     build(,n);
     dfs1(,);
     dfs2(,);
     for(int i=;i<m;i++)
     {
         scanf("%d%d%d",&l[i],&r[i],&z[i]);
         if(l[i]>) q[l[i]-].push_back(Query(z[i],i,));
         q[r[i]].push_back(Query(z[i],i,));
     }
     memset(ans,,sizeof(ans));
     for(int i=;i<n;i++)
     {
         update_chain(i,);
         for(int j=;j<q[i].size();j++)
         {
             Query temp=q[i][j];
             ans[temp.id][temp.dr]=query_chain(temp.ver);
         }
     }
 }

 void print()
 {
     for(int i=;i<m;i++)
     {
         printf("%d\n",mod(ans[i][]-ans[i][]));
     }
 }

 int main()
 {
     read();
     solve();
     print();
 }