bzoj 3626 [LNOI2014]LCA（离线处理+树链剖分，线段树）

3626: [LNOI2014]LCA

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 1272  Solved: 451
[Submit][Status][Discuss]

Description

给出一个n个节点的有根树（编号为0到n-1，根节点为0）。一个点的深度定义为这个节点到根的距离+1。
设dep[i]表示点i的深度，LCA(i,j)表示i与j的最近公共祖先。
有q次询问，每次询问给出l r z，求sigma_{l<=i<=r}dep[LCA(i,z)]。
（即，求在[l,r]区间内的每个节点i与z的最近公共祖先的深度之和）

Input

第一行2个整数n q。
接下来n-1行，分别表示点1到点n-1的父节点编号。
接下来q行，每行3个整数l r z。

Output

输出q行，每行表示一个询问的答案。每个答案对201314取模输出

Sample Input

5 2
0
0
1
1
1 4 3
1 4 2

Sample Output

8
5

HINT

共5组数据，n与q的规模分别为10000,20000,30000,40000,50000。

Source

数据已加强 by saffah

【思路】

离线处理+树链剖分，线段树

Quote

考虑这样的一种暴力，我们把 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)，均可以完成任务。至此，题目已经被我们完美解决。

　　离线处理：保存查询，然后在1..i顺序插入的同时根据查询内容构造答案。

　   打码能力有点弱，WA了几次 T^T

【代码】

 #include<cstdio>
 #include<cstring>
 #include<vector>
 #include<iostream>
 #include<algorithm>
 #define FOR(a,b,c) for(int a=(b);a<=(c);a++)
 using namespace std;

 typedef long long LL;
 const int N = +;
 const int MOD = ;

 struct Node { LL sum; int addv;
 }T[N<<];
 struct Q {
     int flag,x,z,id;
     bool operator < (const Q& rhs) const {
         return x<rhs.x || (x==rhs.x && flag);
     }
 }que[N]; int que_sz;

 int n,q,z; LL ans[N];
 vector<int> g[N];
 //INIT
 int top[N],son[N],dep[N],fa[N],siz[N],w[N];
 void dfs1(int u) {
     son[u]=; siz[u]=;
     for(int i=;i<g[u].size();i++) {
         int v=g[u][i];
         if(v!=fa[u]) {
             fa[v]=u , dep[v]=dep[u]+;
             dfs1(v);
             siz[u]+=siz[v];
             if(siz[v]>siz[son[u]]) son[u]=v;
         }
     }
 }
 void dfs2(int u,int tp) {
     top[u]=tp; w[u]=++z;
     if(son[u]) dfs2(son[u],tp);
     for(int i=;i<g[u].size();i++) {
         int v=g[u][i];
         if(v!=fa[u] && v!=son[u]) dfs2(v,v);
     }
 }
 //SEGMENT TREE
 void pushdown(int u,int tot) {
     if(T[u].addv) {
         T[u<<].sum+=T[u].addv*(tot-(tot>>));
         T[u<<|].sum+=T[u].addv*(tot>>);
         T[u<<].addv+=T[u].addv;
         T[u<<|].addv+=T[u].addv;
         T[u].addv=;
     }
 }
 void update(int u,int L,int R,int l,int r) {
     if(l<=L && R<=r)
         T[u].addv++ , T[u].sum+=(R-L+);
     else {
         pushdown(u,R-L+);
         int M=(L+R)>> , lc=u<< , rc=lc|;
         if(l<=M) update(lc,L,M,l,r);
         if(M<r)  update(rc,M+,R,l,r);
         T[u].sum=T[lc].sum+T[rc].sum;
     }
 }

 LL query(int u,int L,int R,int l,int r) {
     if(l<=L && R<=r)
         return T[u].sum;
     else {
         pushdown(u,R-L+);
         int M=(L+R)>> , lc=u<< , rc=lc|;
         LL ans=;
         if(l<=M) ans+=query(lc,L,M,l,r);
         if(M<r) ans+=query(rc,M+,R,l,r);
         return ans;
     }
 }
 //树链剖分
 void modify(int u) {
     while(u) {
         update(,,z,w[top[u]],w[u]);            //a bug T^T
         u=fa[top[u]];
     }
 }
 LL Ask(int u) {
     LL ans=;
     while(u) {
         ans+=query(,,z,w[top[u]],w[u]);
         u=fa[top[u]];
     }
     return ans;
 }

 void read(int& x) {
     char c=getchar();
     while(!isdigit(c)) c=getchar();
     x=;
     while(isdigit(c))
         x=x*+c-'' , c=getchar();
 }
 int main() {
     read(n),read(q);
     int u,v,w;
     FOR(i,,n) {
         read(u); u++;
         g[u].push_back(i);
         g[i].push_back(u);
     }
     dfs1(),dfs2(,);
     FOR(i,,q) {
         read(u),read(v),read(w);
         u++,v++,w++;
         que[++que_sz]=(Q) {,u-,w,i};
         que[++que_sz]=(Q) {,v,w,i};
     }
     sort(que+,que+que_sz+);
     int j=;
     for(int i=;i<=n;i++) {
         modify(i);
         for(;que[j].x==i;j++) {
             if(que[j].flag)
                 ans[que[j].id]=Ask(que[j].z);
             else
                 ans[que[j].id]=(Ask(que[j].z)-ans[que[j].id])%MOD;
         }
     }
     for(int i=;i<=q;i++) printf("%lld\n",ans[i]);
     return ;
 }