bzoj 3626: [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取模输出

        如果仔细观察会发现有意思的是，如果给一个点从他到根的路径上节点权值全部加一，那么查找另外一个点lca的深度时，答案就是这另外一个点向根的路径和，这一点不得不说出题人真的是机智啊。

        接着就是处理区间的问题了，对于解决区间问题的经典套路就是转化成[1,r]-[1,l-1]的答案，由于这道题前面求出的答案也不会对后面有什么影响，所以就利用这个套路，将询问拆成：减去l-1的答案，加上r的答案的两部分，排序之后，从1-n逐渐加入点，每次加入时给加入的点到根的路径加一，查询时只需要查询该点到根的路径和即可。

       下附AC代码

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<vector>
#define maxn 100005
#define lson (now<<1)
#define rson ((now<<1)|1)
#define mid ((nl+nr)>>1)
using namespace std;
typedef long long ll;
const ll mod=201314;
//以下为基本数组 
ll n,q;
vector<ll>edge[maxn];
ll ans[maxn];
struct nod
{
	ll pos,flag,now,ask;
}que[maxn<<1];
bool operator<(nod a,nod b)
{
	return a.now<b.now;
}
//以下为线段树 
ll sum[maxn<<2],lazy[maxn<<2];
void pushup(ll now)
{
	sum[now]=sum[lson]+sum[rson];
	sum[now]%=mod;
	return;
}
void pushdown(ll now,ll nl,ll nr)
{
	if(lazy[now])
	{
		lazy[lson]+=lazy[now];
		lazy[rson]+=lazy[now];
		lazy[lson]%=mod;
		lazy[rson]%=mod;
		sum[lson]+=lazy[now]*(mid-nl+1);
		sum[lson]%=mod;
		sum[rson]+=lazy[now]*(nr-(mid+1)+1);
		sum[rson]%=mod;
		lazy[now]=0;
	}
	return;
}
void update(ll ql,ll qr,ll add,ll nl,ll nr,ll now)
{
	if(ql<=nl && nr<=qr)
	{
		sum[now]+=nr-nl+1;
		sum[now]%=mod;
		lazy[now]+=add;
		lazy[now]%=mod;
		return;
	}
	pushdown(now,nl,nr);
	if(ql<=mid)
	update(ql,qr,add,nl,mid,lson);
	if(mid<qr)
	update(ql,qr,add,mid+1,nr,rson);
	pushup(now);
}
ll query(ll ql,ll qr,ll nl,ll nr,ll now)
{
	if(ql<=nl && nr<=qr)
	{
		return sum[now];
	}
	pushdown(now,nl,nr);
	ll ans=0;
	if(ql<=mid)
	ans+=query(ql,qr,nl,mid,lson);
	if(mid<qr)
	ans+=query(ql,qr,mid+1,nr,rson);
	ans%=mod;
	pushup(now);
	return ans;
} 
//以下为树链剖分
ll siz[maxn],fa[maxn],dep[maxn];
void dfs1(ll now) 
{
	ll len=edge[now].size();
	siz[now]=1;
	for(ll i=0;i<len;i++)
	{
		ll nex=edge[now][i];
		dep[nex]=dep[now]+1;
		dfs1(nex);
		siz[now]+=siz[nex];
	}
}
ll cnt;
ll anc[maxn],dfn[maxn];
void dfs2(ll now,ll top)
{
	ll len=edge[now].size();
	ll son=0;
	dfn[now]=++cnt;
	anc[now]=top;
	for(ll i=0;i<len;i++)
	{
		ll nex=edge[now][i];
		if(siz[nex]>siz[son])
		{
			son=nex;
		}
	}
	if(son!=0)
	dfs2(son,top);
	for(ll i=0;i<len;i++)
	{
		ll nex=edge[now][i];
		if(nex!=son)
		{
			dfs2(nex,nex);
		}
	}
}
void update(ll now)
{
	while(now!=0)
	{
		update(dfn[anc[now]],dfn[now],1,1,n,1);
		now=fa[anc[now]];
	}
	return;
}
ll query(ll now)
{
	ll ans=0;
	while(now!=0)
	{
		ans+=query(dfn[anc[now]],dfn[now],1,n,1);
		ans%=mod;
		now=fa[anc[now]];
	}
	return ans;
}
int main()
{
	scanf("%lld%lld",&n,&q);
	for(ll i=2;i<=n;i++)
	{
		ll x;
		scanf("%lld",&x);
		x++;
		fa[i]=x;
		edge[x].push_back(i);
	}
	dfs1(1);
	dfs2(1,1);
	for(ll i=1;i<=q;i++)
	{
		ll l,r,z;
		scanf("%lld%lld%lld",&l,&r,&z);
		l++;r++;z++;
		que[i].flag=-1;que[i].now=l-1;
		que[i].pos=i;que[i].ask=z;
		que[i+q].flag=1;que[i+q].now=r;
		que[i+q].pos=i;que[i+q].ask=z;
	}
	sort(que+1,que+1+2*q);
	ll pre=0;
	for(ll i=1;i<=2*q;i++)
	{
		ll now=que[i].now;
		for(ll i=pre+1;i<=now;i++)
		{
			update(i);
		}
		ans[que[i].pos]+=que[i].flag*query(que[i].ask);
		pre=now;
	}
	for(ll i=1;i<=q;i++)
	{
		ans[i]=(ans[i]%mod+mod)%mod;
		printf("%lld\n",ans[i]);
	}
}