【BZOJ3626】LCA（树上差分，树链剖分）

题意：给出一个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的最近公共祖先的深度之和）

n<=50000

思路：From THU爷 LYY

我们考虑这样一种暴力：

对于dep[lca(i,j)]，可以将0~i路径上的点的权值+1，那么答案就是0~j路径上的点的权值之和。

因此对于[l,r]区间，可以将每个点到根节点的权值+1，那么答案ans[l,r]就是0~z路径上的点的权值之和。

显然ans[l,r]=ans[1,r]-ans[1,l-1]。

那么可以树链剖分，然后将0~n-1这n个点插入线段树中，顺便求出答案，复杂度O(nlogn^2)。

const mo=201314;
var t:array[0..500000]of record
                          a,s,l:longint;
                         end;
    head,vet,next,head1,vet1,next1,c,d,
    size,son,tid,id,top,flag,dep,fa,ans:array[0..150000]of longint;
    n,q,i,j,l,r,z,tot,f,v,time,e:longint;


procedure add(a,b:longint);
begin
 inc(tot);
 next[tot]:=head[a];
 vet[tot]:=b;
 head[a]:=tot;
end;

procedure swap(var x,y:longint);
var t:longint;
begin
 t:=x; x:=y; y:=t;
end;

procedure addq(a,b,c1,d1:longint);
begin
 inc(tot);
 next1[tot]:=head1[a];
 vet1[tot]:=b;
 c[tot]:=c1;
 d[tot]:=d1;
 head1[a]:=tot;
end;

procedure dfs1(u:longint);
var e,v,maxsize,t:longint;
begin
 flag[u]:=1; size[u]:=1; son[u]:=0; t:=0;
 e:=head[u];
 while e<>0 do
 begin
  v:=vet[e];
  if flag[v]=0 then
  begin
   dep[v]:=dep[u]+1;
   dfs1(v);
   size[u]:=size[u]+size[v];
   if size[v]>t then
   begin
    t:=size[v]; son[u]:=v;
   end;
   e:=next[e];
  end;
 end;
end;

procedure dfs2(u,ance:longint);
var e,v:longint;
begin
 flag[u]:=1; inc(time); tid[u]:=time; id[time]:=u; top[u]:=ance;
 if son[u]>0 then dfs2(son[u],ance);
 e:=head[u];
 while e<>0 do
 begin
  v:=vet[e];
  if flag[v]=0 then dfs2(v,v);
  e:=next[e];
 end;
end;

procedure hash(var x:longint);
begin
 if x>=mo then x:=x mod mo;
end;
procedure pushdown(x:longint);
var l,r,tmp:longint;
begin
 tmp:=t[x].a;
 if tmp=0 then exit;
 l:=x<<1; r:=l+1;
 t[l].a:=t[l].a+tmp; hash(t[l].a);
 t[r].a:=t[r].a+tmp; hash(t[r].a);
 t[l].s:=t[l].s+t[l].l*tmp; hash(t[l].s);
 t[r].s:=t[r].s+t[r].l*tmp; hash(t[r].s);
 t[x].a:=0;
end;

procedure pushup(x:longint);
var l,r:longint;
begin
 l:=x<<1; r:=l+1;
 t[x].s:=t[l].s+t[r].s; hash(t[x].s);
end;

procedure build(l,r,p:longint);
var mid:longint;
begin
 t[p].l:=r-l+1;
 if l=r then exit;
 mid:=(l+r)>>1;
 build(l,mid,p<<1);
 build(mid+1,r,p<<1+1);
end;

function query(l,r,x,y,p:longint):longint;
var mid:longint;
begin
 if (l>=x)and(r<=y) then exit(t[p].s);
 mid:=(l+r)>>1;
 pushdown(p);
 query:=0;
 if x<=mid then query:=query+query(l,mid,x,y,p<<1);
 if y>mid then query:=query+query(mid+1,r,x,y,p<<1+1);
// if query>=mo then query:=query-mo;
 hash(query);
end;

procedure update(l,r,x,y,p:longint);
var mid:longint;
begin
 if (l>=x)and(r<=y) then
 begin
  inc(t[p].a);
 // if t[p].a>=mo then t[p].a:=t[p].a-mo;
  hash(t[p].a);
  t[p].s:=t[p].s+t[p].l;
  hash(t[p].s);
 // if t[p].s>=mo then t[p].s:=t[p].s-mo;
  exit;
 end;
 mid:=(l+r)>>1;
 pushdown(p);
 if x<=mid then update(l,mid,x,y,p<<1);
 if y>mid then update(mid+1,r,x,y,p<<1+1);
 pushup(p);
end;

procedure change(k:longint);
begin
 while top[k]<>1 do
 begin
  update(1,n,tid[top[k]],tid[k],1);
  k:=fa[top[k]];
 end;
 update(1,n,1,tid[k],1);
end;

function clac(k:longint):longint;
begin
 clac:=0;
 while top[k]<>1 do
 begin
  clac:=clac+query(1,n,tid[top[k]],tid[k],1);
//  if clac>=mo then clac:=clac-mo;
  hash(clac);
  k:=fa[top[k]];
 end;
 clac:=clac+query(1,n,1,tid[k],1);
// if clac>=mo then clac:=clac-mo;
 hash(clac);
end;

begin
 assign(input,'bzoj3626.in'); reset(input);
 assign(output,'bzoj3626.out'); rewrite(output);
 readln(n,q);
 for i:=2 to n do
 begin
  read(fa[i]); inc(fa[i]);
  add(fa[i],i);
 end;
 dfs1(1);
 fillchar(flag,sizeof(flag),0);
 dfs2(1,1);
 tot:=0;
 for i:=1 to q do
 begin
  readln(l,r,z);
  inc(l); inc(r); inc(z);
  addq(l-1,i,z,-1);
  addq(r,i,z,1);
 end;
 build(1,n,1);
 for i:=1 to n do
 begin
  change(i);
  e:=head1[i];
  while e<>0 do
  begin
   v:=vet1[e]; j:=c[e]; f:=d[e];
   ans[v]:=(ans[v]+f*clac(j) mod mo+mo) mod mo;
   e:=next1[e];
  end;
 end;
 for i:=1 to q do writeln(ans[i]);

 close(input);
 close(output);
end.