BZOJ 3626 [LNOI2014]LCA：树剖 + 差分 + 离线【将深度转化成点权之和】

题目链接：http://www.lydsy.com/JudgeOnline/problem.php?id=3626

题意：

　　给出一个n个节点的有根树（编号为0到n-1，根节点为0，n <= 50000）。

　　一个点的深度定义为这个节点到根的距离+1。

　　设dep[i]表示点i的深度，LCA(i,j)表示i与j的最近公共祖先。

　　有q次询问，每次询问给出l,r,z，求∑ dep[LCA(i,z)] (l<=i<=r)。

　　（即，求在[l,r]区间内的每个节点i与z的最近公共祖先的深度之和）

题解：

　　假设有一棵所有点都为0的树。

　　如果将x到root路径上的点都+1，则dep[LCA(x,y)] = y到root路径上的点权之和，且这个操作具有叠加性。（树剖）

　　所以对于询问query(l to r) = query(r) - query(l-1)。（差分）

　　显然，只需要求出在询问中有的l和r的query。

　　所以依次枚举节点i = 0 to n-1，将i到root的路径+1，如果i是某一些询问的l或r，则记录相应的query(z)。（离线）

　　总复杂度O((n+q)*logn*logn)

AC Code:

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <vector>
#define MAX_N 200005
#define MAX_M 50005
#define MOD 201314

using namespace std;

struct Query
{
    int ver;
    int id;
    int dr;
    Query(int _ver,int _id,int _dr)
    {
        ver=_ver;
        id=_id;
        dr=_dr;
    }
    Query(){};
};

int n,m;
int tot=0;
int cnt=0;
int l[MAX_M];
int r[MAX_M];
int z[MAX_M];
int dat[MAX_N];
int lazy[MAX_N];
int lson[MAX_N];
int rson[MAX_N];
int par[MAX_N];
int dep[MAX_N];
int siz[MAX_N];
int tp[MAX_N];
int son[MAX_N];
int dfsx[MAX_N];
int ans[MAX_M][2];
vector<int> edge[MAX_N];
vector<Query> q[MAX_M];

inline int mod(int x)
{
    return (x%MOD+MOD)%MOD;
}

int build(int l,int r)
{
    int rt=++tot;
    dat[rt]=lazy[rt]=0;
    lson[rt]=rson[rt]=0;
    if(l<r)
    {
        int mid=(l+r)>>1;
        lson[rt]=build(l,mid);
        rson[rt]=build(mid+1,r);
    }
    return rt;
}

void push_down(int k,int len)
{
    if(lazy[k])
    {
        if(lson[k])
        {
            dat[lson[k]]=mod(dat[lson[k]]+lazy[k]*(len-(len>>1)));
            lazy[lson[k]]=mod(lazy[lson[k]]+lazy[k]);
        }
        if(rson[k])
        {
            dat[rson[k]]=mod(dat[rson[k]]+lazy[k]*(len>>1));
            lazy[rson[k]]=mod(lazy[rson[k]]+lazy[k]);
        }
        lazy[k]=0;
    }
}

void push_up(int k)
{
    dat[k]=0;
    if(lson[k]) dat[k]=mod(dat[k]+dat[lson[k]]);
    if(rson[k]) dat[k]=mod(dat[k]+dat[rson[k]]);
}

void update(int a,int b,int k,int l,int r,int x)
{
    if(a<=l && r<=b)
    {
        dat[k]=mod(dat[k]+(r-l+1)*x);
        lazy[k]=mod(lazy[k]+x);
        return;
    }
    if(r<a || b<l) return;
    push_down(k,r-l+1);
    int mid=(l+r)>>1;
    update(a,b,lson[k],l,mid,x);
    update(a,b,rson[k],mid+1,r,x);
    push_up(k);
}

int query(int a,int b,int k,int l,int r)
{
    if(a<=l && r<=b) return dat[k];
    if(r<a || b<l) return 0;
    push_down(k,r-l+1);
    int mid=(l+r)>>1;
    int v1=query(a,b,lson[k],l,mid);
    int v2=query(a,b,rson[k],mid+1,r);
    return mod(v1+v2);
}

void dfs1(int now,int d)
{
    dep[now]=d;
    siz[now]=1;
    for(int i=0;i<edge[now].size();i++)
    {
        int temp=edge[now][i];
        if(temp!=par[now])
        {
            dfs1(temp,d+1);
            siz[now]+=siz[temp];
        }
    }
}

void dfs2(int now,int anc)
{
    tp[now]=anc;
    son[now]=-1;
    dfsx[now]=++cnt;
    for(int i=0;i<edge[now].size();i++)
    {
        int temp=edge[now][i];
        if((son[now]==-1 || siz[temp]>siz[son[now]]) && temp!=par[now])
        {
            son[now]=temp;
        }
    }
    if(son[now]!=-1) dfs2(son[now],anc);
    for(int i=0;i<edge[now].size();i++)
    {
        int temp=edge[now][i];
        if(temp!=par[now] && temp!=son[now]) dfs2(temp,temp);
    }
}

void update_chain(int a,int x)
{
    while(tp[a]!=0)
    {
        update(dfsx[tp[a]],dfsx[a],1,1,n,x);
        a=par[tp[a]];
    }
    update(1,dfsx[a],1,1,n,x);
}

int query_chain(int a)
{
    int sum=0;
    while(tp[a]!=0)
    {
        sum=mod(sum+query(dfsx[tp[a]],dfsx[a],1,1,n));
        a=par[tp[a]];
    }
    sum=mod(sum+query(1,dfsx[a],1,1,n));
    return sum;
}

void read()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<n;i++)
    {
        scanf("%d",&par[i]);
        edge[i].push_back(par[i]);
        edge[par[i]].push_back(i);
    }
}

void solve()
{
    build(1,n);
    dfs1(0,0);
    dfs2(0,0);
    for(int i=0;i<m;i++)
    {
        scanf("%d%d%d",&l[i],&r[i],&z[i]);
        if(l[i]>0) q[l[i]-1].push_back(Query(z[i],i,0));
        q[r[i]].push_back(Query(z[i],i,1));
    }
    memset(ans,0,sizeof(ans));
    for(int i=0;i<n;i++)
    {
        update_chain(i,1);
        for(int j=0;j<q[i].size();j++)
        {
            Query temp=q[i][j];
            ans[temp.id][temp.dr]=query_chain(temp.ver);
        }
    }
}

void print()
{
    for(int i=0;i<m;i++)
    {
        printf("%d
",mod(ans[i][1]-ans[i][0]));
    }
}

int main()
{
    read();
    solve();
    print();
}