【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。

题解
Orz Hzwer
来自http://hzwer.com/3891.html
直接引用清华爷gconeice的题解吧

显然，暴力求解的复杂度是无法承受的。
考虑这样的一种暴力，我们把 z 到根上的点全部打标记，对于 l 到 r 之间的点，向上搜索到第一个有标记的点求出它的深度统计答案。观察到，深度其实就是上面有几个已标记了的点（包括自身）。所以，我们不妨把 z 到根的路径上的点全部 +1，对于 l 到 r 之间的点询问他们到根路径上的点权和。仔细观察上面的暴力不难发现，实际上这个操作具有叠加性，且可逆。也就是说我们可以对于 l 到 r 之间的点 i，将 i 到根的路径上的点全部 +1, 转而询问 z 到根的路径上的点（包括自身）的权值和就是这个询问的答案。把询问差分下，也就是用 [1, r] − [1, l − 1] 来计算答案，那么现在我们就有一个明显的解法。从 0 到 n − 1 依次插入点 i，即将 i 到根的路径上的点全部+1。离线询问答案即可。我们现在需要一个数据结构来维护路径加和路径求和，显然树链剖分或LCT 均可以完成这个任务。树链剖分的复杂度为 O((n + q)· log n · log n)，LCT的复杂度为 O((n + q)· log n)，均可以完成任务。至此，题目已经被我们完美解决。

代码

#include<bits/stdc++.h>
#define ll long long
#define inf 1000000000
#define mod 201314
using namespace std;
const int N=50005;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if (ch=='-') f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
struct node{int q,z,id,f;}a[N<<1];
int tot,n,m,q,Head[N],ret[N],Next[N],ans[N];
int t[N<<2],lazy[N<<2],size[N],son[N],fa[N],pos[N],tim,bl[N];
bool cmp(node a,node b){return a.q<b.q;}
inline void ins(int u,int v)
{
    ret[++tot]=v;Next[tot]=Head[u];Head[u]=tot;
}
void dfs1(int u)
{
    size[u]=1;
    for (int i=Head[u];i;i=Next[i])
    {
        fa[ret[i]]=u;dfs1(ret[i]);
        if (son[u]==0||size[ret[i]]>size[son[u]]) son[u]=ret[i];
        size[u]+=size[ret[i]];
    }
}
void dfs2(int u,int chain)
{
    pos[u]=++tim;bl[u]=chain;
    if (son[u]) dfs2(son[u],chain);
    for (int i=Head[u];i;i=Next[i])
    {
        if (son[u]!=ret[i]) dfs2(ret[i],ret[i]);
    }
}
inline void pushdown(int k,int l,int r)
{
    if (l==r) return;
    int mid=(l+r)>>1;
    t[k<<1]+=lazy[k]*(mid-l+1);t[k<<1|1]+=lazy[k]*(r-mid);
    lazy[k<<1]+=lazy[k];lazy[k<<1|1]+=lazy[k];lazy[k]=0;
}
void modify(int k,int l,int r,int x,int y)
{
    if (lazy[k]) pushdown(k,l,r);
    if (l==x&&r==y){lazy[k]++;t[k]+=r-l+1;return;}
    int mid=(l+r)>>1;
    if (y<=mid) modify(k<<1,l,mid,x,y);
    else if (x>mid) modify(k<<1|1,mid+1,r,x,y);
    else modify(k<<1,l,mid,x,mid),modify(k<<1|1,mid+1,r,mid+1,y);
    t[k]=(t[k<<1]+t[k<<1|1]);
}
void change(int x)
{
    while (bl[x]!=bl[1])
    {
        modify(1,1,n,pos[bl[x]],pos[x]);
        x=fa[bl[x]];
    }
    modify(1,1,n,pos[1],pos[x]);
}
int query(int k,int l,int r,int x,int y)
{
    if (lazy[k]) pushdown(k,l,r);
    if (l==x&&r==y) return t[k];
    int mid=(l+r)>>1;
    if (y<=mid) return query(k<<1,l,mid,x,y);
    else if (x>mid) return query(k<<1|1,mid+1,r,x,y);
    else return (query(k<<1,l,mid,x,mid)+query(k<<1|1,mid+1,r,mid+1,y))%mod;
}
int que(int x)
{
    int ans=0;
    while (bl[x]!=bl[1])
    {
        (ans+=query(1,1,n,pos[bl[x]],pos[x]))%=mod;
        x=fa[bl[x]];
    }
    (ans+=query(1,1,n,pos[1],pos[x]))%=mod;
    return ans;
}
int main()
{
    n=read();q=read();
    for (int i=2;i<=n;i++)
    {
        int x=read()+1;
        ins(x,i);
    }
    for (int i=1;i<=q;i++)
    {
        int l=read()+1,r=read()+1,z=read()+1;
        a[++m].q=l-1;a[m].z=z;a[m].f=-1;a[m].id=i;
        a[++m].q=r;a[m].z=z;a[m].f=1;a[m].id=i;
    }
    sort(a+1,a+m+1,cmp);
    dfs1(1);dfs2(1,1);
    int P=1;
    for (int i=1;i<=m;i++)
    {
        while (P<=a[i].q) change(P++);
        (ans[a[i].id]+=a[i].f*que(a[i].z))%=mod;
    }
    for (int i=1;i<=q;i++) printf("%d\n",(ans[i]+mod)%mod);
    return 0;
}