[BZOJ3626][LNOI2014][树链剖分][差分][离线处理]LCA

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。

题目名字叫LCA，其实跟LCA并没有什么关系，因为如果5e4个询问对每个点依次求LCA肯定要GG

我们首先来看LCA深度的另一种求法，假设我们要dep[LCA(u,v)]，那么可以在u到根节点的所有点打上标记(权值加1)，然后再统计出v到根节点的路径上的sum,这个即是要求得dep[LCA(u,v)]

不难发现，这个算法是可以叠加的，即对于询问[L，R，goal]，我们可以将[L,R]的点到根的路径都打上标记，再同级goal到跟的标记总数，即为单次询问答案

那么单次询问就可以用树链剖分来处理了，时间复O(nlog*logn),再加上q次询问，显然还是无法承受

又可以想到，对于一次询问，我们是可以差分的，即ans=[1,R,goal]-[1,L-1,goal]，那现在就可以进行离线处理了

从1-n不断打标记，并将询问排好序后看当前是否有询问需要处理

问题就可以解决了

#include<cstring>
#include<cstdio>
#include<algorithm>
#include<cctype>
using namespace std;
const int maxn=5e4+5;
const int mod=201314;
int n,m,cnt,edge,cur,ans[maxn];
int to[maxn],nxt[maxn],head[maxn];
int fa[maxn],son[maxn],size[maxn],dfn[maxn],top[maxn];
struct Data
{
int pos,order,flag,goal;
bool operator<(const Data &x)const
{
return pos<x.pos;
}
}data[maxn<<1];
struct Seg
{
int L,R,sum,lazy;
}seg[maxn<<2];
#define L(x) seg[x].L
#define R(x) seg[x].R
#define sum(x) seg[x].sum
#define lazy(x) seg[x].lazy
#define Lson(x) (x<<1)
#define Rson(x) (x<<1|1)
int readint()
{
int x=0; char ch=getchar();
while (!isdigit(ch)) ch=getchar();
while (isdigit(ch)) {x=(x<<1)+(x<<3)+ch-'0'; ch=getchar();}
return x;
}
void edge_add(int u,int v)
{
to[++edge]=v; nxt[edge]=head[u]; head[u]=edge;
}
void dfs1(int u)
{
size[u]=1;
for (int E=head[u];E;E=nxt[E])
{
int v=to[E];
if (v==fa[u]) continue;
dfs1(v); size[u]+=size[v];
if (size[v]>size[son[u]]) son[u]=v;
}
}
void dfs2(int u,int tp)
{
top[u]=tp; dfn[u]=++cnt;
if (son[u]) dfs2(son[u],tp);
for (int E=head[u];E;E=nxt[E])
{
int v=to[E];
if (v==fa[u]||v==son[u]) continue;
dfs2(v,v);
}
}
void build(int s,int t,int tr)
{
L(tr)=s; R(tr)=t;
if (s==t) return ;
int mid=(s+t)>>1;
build(s,mid,Lson(tr)); build(mid+1,t,Rson(tr));
}
void pushup(int tr)
{
sum(tr)=(sum(Lson(tr))+sum(Rson(tr)))%mod;
}
void pushdown(int tr)
{
lazy(Lson(tr))+=lazy(tr); lazy(Rson(tr))+=lazy(tr);
sum(Lson(tr))+=lazy(tr)*(R(Lson(tr))-L(Lson(tr))+1); sum(Lson(tr))%=mod;
sum(Rson(tr))+=lazy(tr)*(R(Rson(tr))-L(Rson(tr))+1); sum(Rson(tr))%=mod;
lazy(tr)=0;
}
void update2(int s,int t,int tr)
{
if (s==L(tr)&&t==R(tr))
{
sum(tr)+=t-s+1; sum(tr)%=mod; lazy(tr)++;
return ;
}
pushdown(tr);
int mid=(L(tr)+R(tr))>>1;
if (t<=mid) update2(s,t,Lson(tr));
else if (s>=mid+1) update2(s,t,Rson(tr));
else update2(s,mid,Lson(tr)),update2(mid+1,t,Rson(tr));
pushup(tr);
}
void update1(int u)
{
while (top[u]^1)
{
update2(dfn[top[u]],dfn[u],1);
u=fa[top[u]];
}
update2(1,dfn[u],1);
}
int query2(int s,int t,int tr)
{
if (s==L(tr)&&t==R(tr)) return sum(tr);
pushdown(tr);
int mid=(L(tr)+R(tr))>>1;
if (t<=mid) return query2(s,t,Lson(tr));
if (s>=mid+1) return query2(s,t,Rson(tr));
return query2(s,mid,Lson(tr))+query2(mid+1,t,Rson(tr));
}
int query1(int u)
{
int ret=0;
while (top[u]^1)
{
ret+=query2(dfn[top[u]],dfn[u],1); ret%=mod;
u=fa[top[u]];
}
ret+=query2(1,dfn[u],1);
return ret%mod;
}
int main()
{
n=readint(); m=readint();
for (int i=2;i<=n;i++) fa[i]=readint(),edge_add(++fa[i],i);
dfs1(1); dfs2(1,1); build(1,n,1);
for (int i=1;i<=m;i++)
{
int u=((i-1)<<1)+1,v=u+1;
data[u].pos=readint(); data[v].pos=readint()+1;
data[u].goal=data[v].goal=readint()+1;
data[u].order=data[v].order=i;
data[u].flag=-1; data[v].flag=1;
}
sort(data,data+(m<<1|1));
for (int i=1;i<=(m<<1);i++)
{
if (!data[i].pos) continue;
while (cur<data[i].pos)
{
cur++; update1(cur);
}
ans[data[i].order]+=(query1(data[i].goal)*data[i].flag);
}
for (int i=1;i<=m;i++) printf("%d",(ans[i]+mod)%mod),putchar('\n');
return 0;
}