[BZOJ3626][LNOI2014]LCA（离线+链剖）

=== ===

这里放传送门

=== ===

题解

感觉这题思路还是比较神的。。

对于一个点u，我们要查它跟某个给定点z的LCA的深度，那么如果我们把u这个点到根节点的路径全都打上+1的标记，那么z到根的路径上的标记数目就是u和z的LCA的深度。这个东西画一画就感觉比较科学了。。如果是对于两个点u和v要求跟z的LCA的深度，那就把u和v都打上到根的一串标记然后查z到根的标记个数就可以了。。。

那我们可以离线询问，离线完了以后就可以把每个询问拆成两个，因为这个东西显然是满足前缀和相减的性质。那问题就变成了有一堆[1,n]这样的区间要求回答这个询问。结合上面那种方法，我们可以把询问们都按照右端点从小到大排序，然后从1号点开始一个一个往树上打一串标记。每次当走到i这个点的时候说明1-i所有点的标记已经都被加进去了，那么这个时候就可以处理[1,i]这样的询问了。

代码

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int n,Q,p[50010],a[50010],next[50010],top[50010],size[50010],son[50010],fa[50010],tot,cnt;
int deep[50010],sum[200010],dlt[200010],ans[50010][2],cur[50010],ptr,w[50010],qcnt;
void add(int x,int y){
tot++;a[tot]=y;next[tot]=p[x];p[x]=tot;
}
struct question{
int r,z,id,iid;
}q[100010];
int comp(question a,question b){
return a.r<b.r;
}
void addquery(int r,int z,int id,int iid){
++qcnt;q[qcnt].r=r;q[qcnt].z=z;q[qcnt].id=id;q[qcnt].iid=iid;
}
void dfs(){
int u=1;
bool flag;
while (true){
flag=false;
if (deep[u]==0){
deep[u]=deep[fa[u]]+1;
size[u]=1;son[u]=0;cur[u]=p[u];
}
for (int i=cur[u];i!=0;i=next[i]){
int v=a[i];
cur[u]=next[i];fa[v]=u;
u=v;flag=true;break;
}
if (flag==false)
if (u==1) break;
else{
int v=fa[u];
size[v]+=size[u];
if (size[son[v]]<size[u]) son[v]=u;
u=fa[u];
}
}
}
void dfs_again(){
int u=1,tp=1;
bool flag;
while (true){
flag=false;
if (top[u]==0){
top[u]=tp;w[u]=++cnt;cur[u]=p[u];
if (son[u]!=0){u=son[u];continue;}
}
for (int i=cur[u];i!=0;i=next[i]){
cur[u]=next[i];u=a[i];
tp=a[i];flag=true;break;
}
if (flag==false)
if (u==1) break;
else u=fa[u];
}
}
void update(int i){
sum[i]=sum[i<<1]+sum[(i<<1)+1];
}
void pushdown(int i,int l,int r){
if (dlt[i]!=0){
int mid=(l+r)>>1;
sum[i<<1]+=(mid-l+1)*dlt[i];
sum[(i<<1)+1]+=(r-mid)*dlt[i];
dlt[i<<1]+=dlt[i];dlt[(i<<1)+1]+=dlt[i];
dlt[i]=0;
}
}
void add(int i,int l,int r,int left,int right){
if (left<=l&&right>=r){
sum[i]+=r-l+1;dlt[i]++;
return;
}
int mid=(l+r)>>1;
pushdown(i,l,r);
if (left<=mid) add(i<<1,l,mid,left,right);
if (right>mid) add((i<<1)+1,mid+1,r,left,right);
update(i);
}
void change(int x,int y){
while (top[x]!=top[y]){
if (deep[top[x]]<deep[top[y]]) swap(x,y);
add(1,1,n,w[top[x]],w[x]);
x=fa[top[x]];
}
if (deep[x]>deep[y]) swap(x,y);
add(1,1,n,w[x],w[y]);
}
int ask(int i,int l,int r,int left,int right){
if (left<=l&&right>=r) return sum[i];
int mid=(l+r)>>1,ans=0;
pushdown(i,l,r);
if (left<=mid) ans+=ask(i<<1,l,mid,left,right);
if (right>mid) ans+=ask((i<<1)+1,mid+1,r,left,right);
return ans;
}
int query(int x,int y){
int ans=0;
while (top[x]!=top[y]){
if (deep[top[x]]<deep[top[y]]) swap(x,y);
ans+=ask(1,1,n,w[top[x]],w[x]);
x=fa[top[x]];
}
if (deep[x]>deep[y]) swap(x,y);
ans+=ask(1,1,n,w[x],w[y]);
return ans;
}
int main()
{
scanf("%d%d",&n,&Q);
for (int i=2;i<=n;i++){
int fa;scanf("%d",&fa);++fa;
add(fa,i);
}
dfs();dfs_again();
for (int i=1;i<=Q;i++){
int l,r,z;
scanf("%d%d%d",&l,&r,&z);
++l;++r;++z;
addquery(l-1,z,i,0);
addquery(r,z,i,1);//把每个询问拆成两个
}
sort(q+1,q+qcnt+1,comp);
ptr=1;
while (q[ptr].r==0){
ans[q[ptr].id][q[ptr].iid]=0;
++ptr;
}
for (int i=1;i<=n;i++){
change(1,i);
while (q[ptr].r==i){
ans[q[ptr].id][q[ptr].iid]=query(1,q[ptr].z);
++ptr;
}
}
for (int i=1;i<=Q;i++)
printf("%d\n",(ans[i][1]-ans[i][0])%201314);
return 0;
}

偏偏在最后出现的补充说明

离线处理有时候往往可以利用某种单调性，通过动态维护来放宽单个操作的时限。