【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=;
 var t:array[..]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[..]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]:=; size[u]:=; son[u]:=; t:=;
  e:=head[u];
  while e<> do
  begin
   v:=vet[e];
   if flag[v]= then
   begin
    dep[v]:=dep[u]+;
    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]:=; inc(time); tid[u]:=time; id[time]:=u; top[u]:=ance;
  if son[u]> then dfs2(son[u],ance);
  e:=head[u];
  while e<> do
  begin
   v:=vet[e];
   if flag[v]= 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= then exit;
  l:=x<<; r:=l+;
  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:=;
 end;

 procedure pushup(x:longint);
 var l,r:longint;
 begin
  l:=x<<; r:=l+;
  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+;
  if l=r then exit;
  mid:=(l+r)>>;
  build(l,mid,p<<);
  build(mid+,r,p<<+);
 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)>>;
  pushdown(p);
  query:=;
  if x<=mid then query:=query+query(l,mid,x,y,p<<);
  if y>mid then query:=query+query(mid+,r,x,y,p<<+);
 // 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)>>;
  pushdown(p);
  if x<=mid then update(l,mid,x,y,p<<);
  if y>mid then update(mid+,r,x,y,p<<+);
  pushup(p);
 end;

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

 function clac(k:longint):longint;
 begin
  clac:=;
  while top[k]<> do
  begin
   clac:=clac+query(,n,tid[top[k]],tid[k],);
 //  if clac>=mo then clac:=clac-mo;
   hash(clac);
   k:=fa[top[k]];
  end;
  clac:=clac+query(,n,,tid[k],);
 // 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:= to n do
  begin
   read(fa[i]); inc(fa[i]);
   add(fa[i],i);
  end;
  dfs1();
  fillchar(flag,sizeof(flag),);
  dfs2(,);
  tot:=;
  for i:= to q do
  begin
   readln(l,r,z);
   inc(l); inc(r); inc(z);
   addq(l-,i,z,-);
   addq(r,i,z,);
  end;
  build(,n,);
  for i:= to n do
  begin
   change(i);
   e:=head1[i];
   while e<> 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:= to q do writeln(ans[i]);

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