[树链剖分][bzoj3626]

3626: [LNOI2014]LCA

Time Limit: 10 Sec Memory Limit: 128 MB
Submit: 1942 Solved: 767
[Submit][Status][Discuss]
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。

Source

数据已加强 by saffah

原题解
（发现这个题的题解基本上都是复制那个神犇的）
直接复制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)，均可以完成任务。至此，题目已经被我们完美解决。

讲的还是很清楚，这里解释几点自己编写代码时遇到的问题。
当时一直不是很能理解怎么他就很容易离线做这道题了，原来是想错了一个东西，他的区间是点，这些点在树上也不一定是连续的。然后把这些点排序后，依次插入时，当这个点是一个问题的询问节点时，此时到c的距离存下来，，然后继续插入点，这个时候的插入点就相当于是在把区间中的点与1的路径全部加1,当道结束节点时，再算到1的路径，就完美的差分了。。。
哦，我看hzwer神的程序，有一个地方很巧妙，当时有同学问我，如果是用一个节点是多个问题的询问节点，那么循环问题*2就很好的解决了。。就不要直接循环n个点。

代码：
（记住是否要mod&&线段树查询记住pushdown)

#include<iostream>
#include<cstdio>
#include<ctime>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<string>
#include<set>
#include<map>
#include<vector>
#include<queue>
#include<algorithm>
#ifdef WIN32
#define AUTO "%I64d"
#else
#define AUTO "%lld"
#endif
#define INF 0x3f3f3f3f
#define clock CLOCKS_PER_SEC
#define cle(x) memset(x,0,sizeof(x))
#define maxcle(x) memset(x,0x3f,sizeof(x))
#define mincle(x) memset(x,-1,sizeof(x))
#define maxx(x1,x2,x3) max(x1,max(x2,x3))
#define minn(x1,x2,x3) min(x1,min(x2,x3))
#define cop(a,x) memcpy(x,a,sizeof(a))
#define FROP "bzoj"
#define C(a,b) next_permutation(a,b)
#define LL long long
#define smin(x,tmp) x=min(x,tmp)
#define smax(x,tmp) x=max(x,tmp)
using namespace std;
const int N = 50010,mod=201314;
struct Edge{int to,ne; Edge(int to=0,int ne=0):to(to),ne(ne){ }}ed[N];
struct que{int ans1,ans2,c;}q[N];
struct delta
{
    int p,in; 
    bool flag;
    bool operator < (const delta &a)const
    {
        return p<a.p;
    }
}a[N*2];    
int head[N],fa[N],son[N],sz[N],top[N],depth[N],tii[N],_tii[N],Index,n,m;
//----------------------------------------------------------------
void dfs1(int u)
{
    sz[u]=1;
    for(int i = head[u] ; i ; i= ed[i].ne)
    {
        int v=ed[i].to;
        if(fa[u]==v)continue;
        fa[v]=u;
        depth[v]=depth[u]+1;
        dfs1(v);
        if(sz[v]>sz[son[u]])son[u]=v;
        sz[u]+=sz[v];
    }
}
void dfs2(int u,int tp)
{
    tii[u]=++Index;
    _tii[Index]=u;
    top[u]=tp;
    if(!son[u])return;
    dfs2(son[u],tp);
    for(int i = head[u] ; i ; i =ed[i].ne)
    {
        int v=ed[i].to;
        if(fa[u]==v||son[u]==v)continue;
        dfs2(v,v);
    }
}
//----------------------------------------
#define lson rt<<1,l,mid
#define rson rt<<1|1,mid+1,r
struct Node{int dis,add,size;}node[N*4];
#define dis(x) node[x].dis
#define add(x) node[x].add
#define size(x) node[x].size
void build(int rt,int l,int r)
{
    if(l==r)
    {
        size(rt)=1;
        return;
    }
    int mid=(l+r)>>1;
    build(lson);
    build(rson);
    size(rt)=size(rt<<1)+size(rt<<1|1);
}
void pushdown(int rt)
{
    if(!add(rt))return;
    add(rt<<1)=(add(rt<<1)+add(rt))%mod;
    add(rt<<1|1)=(add(rt<<1|1)+add(rt))%mod;
    dis(rt<<1)=(dis(rt<<1)+add(rt)*size(rt<<1))%mod;
    dis(rt<<1|1)=(dis(rt<<1|1)+add(rt)*size(rt<<1|1));
    add(rt)=0;
}
void update(int rt,int l,int r,int L,int R)
{
    if(l>=L&&r<=R)
    {
        add(rt)++;
        dis(rt)=(dis(rt)+size(rt))%mod;
        return;
    }
    pushdown(rt);
    int mid=(l+r)>>1;
    if(mid>=L)update(lson,L,R);
    if(mid<R)update(rson,L,R);
    dis(rt)=(dis(rt<<1)+dis(rt<<1|1))%mod;
}
int query(int rt,int l,int r,int L,int R)
{
    if(l>=L&&r<=R)return dis(rt);
    int mid=(l+r)>>1;
    LL res=0;
    pushdown(rt);
    if(mid>=L)res=(res+query(lson,L,R))%mod;
    if(mid<R)res=(res+query(rson,L,R))%mod;
    return res;
}
void solve_update(int x,int y)
{
    while(top[x]^top[y])
    {
        update(1,1,n,tii[top[y]],tii[y]);
        y=fa[top[y]];
    }
    update(1,1,n,tii[x],tii[y]);
}
int solve_query(int x,int y)
{
    int sum=0;
    while(top[x]^top[y])
    {
        sum=(sum+query(1,1,n,tii[top[y]],tii[y]))%mod;
        y=fa[top[y]];
    }
    sum=(sum+query(1,1,n,tii[x],tii[y]))%mod;
    return sum;
}
int main()
{
    freopen(FROP".in","r",stdin);
    freopen(FROP".out","w",stdout);
    scanf("%d%d",&n,&m);
    for(int i = 2; i <= n; i++)
    {
        int x;
        scanf("%d",&x);
        ed[i-1]=Edge(i,head[x+1]);
        head[x+1]=i-1;
    }
    for(int i = 1; i <= m; i++)
    {
        int l,r,c;
        scanf("%d%d%d",&l,&r,&c);
        l++,r++,c++;
        a[i*2-1].p=l-1,a[i*2-1].in=i,a[i*2-1].flag=true;
        a[i*2].p=r,a[i*2].in=i,a[i*2].flag=false;
        q[i].c=c;
    }
    dfs1(1);
    dfs2(1,1);
    build(1,1,n);
    sort(a+1,a+m*2+1);
    int now=1;
    for(int i = 1; i <=m*2;i++)
    {
        while(now<=a[i].p)
        {
            solve_update(1,now);
            now++;
        }
        if(a[i].flag)q[a[i].in].ans1=solve_query(1,q[a[i].in].c);
        else q[a[i].in].ans2=solve_query(1,q[a[i].in].c);
    }
    for(int i = 1; i <= m; i++)
    printf("%d\n",((q[i].ans2-q[i].ans1)%mod+mod)%mod);
    return 0;
}