bzoj 3626 [LNOI2014]LCA

最新推荐文章于 2018-08-10 20:54:25 发布

原创最新推荐文章于 2018-08-10 20:54:25 发布 · 318 阅读

0 ·

CC 4.0 BY-SA版权

树链剖分专栏收录该内容

5 篇文章

订阅专栏

本文介绍了一种针对LCA问题的有效求解方法，通过树链剖分或LCT实现路径加和路径求和的维护，解决了大规模数据下的查询效率问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

3626: [LNOI2014]LCA

Time Limit: 10 Sec Memory Limit: 128 MB
Submit: 2523 Solved: 998
[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

1 4 3

1 4 2

Sample Output

HINT

共5组数据，n与q的规模分别为10000,20000,30000,40000,50000。

【分析】
引用自hzwer

显然，暴力求解的复杂度是无法承受的。
考虑这样的一种暴力，我们把 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)，均可以完成任务。至此，题目已经被我们完美解决。

Attention！
最后的结果要+mod再%mod！
要不然出现负数嘿嘿嘿(雾)

【代码】

//LCA
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define M(a) memset(a,0,sizeof a)
#define fo(i,j,k) for(i=j;i<=k;i++)
using namespace std;
const int mxn=50005,mod=201314;
int n,m,cnt,tot;
int head[mxn],pos[mxn],res[mxn];
struct edge {int to,next;} f[mxn];
struct tree
{
    int fa,son,top,dep,sz,s,e;
}e[mxn];
struct lenth
{
    int l,r,sum,mark;
}t[mxn<<2];
struct question
{
    int l,r,z,id;
}q[mxn];
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;
}
inline bool comp1(question x,question y)
{
    return x.l<y.l;
}
inline bool comp2(question x,question y)
{
    return x.r<y.r;
}
inline void add(int u,int v)
{
    f[++cnt].to=v,f[cnt].next=head[u],head[u]=cnt;
}
inline void dfs1(int u)
{
    e[u].sz=1;
    for(int i=head[u];i;i=f[i].next)
    {
        int v=f[i].to;
        if(v==e[u].fa) continue;
        e[v].fa=u;
        e[v].dep=e[u].dep+1;
        dfs1(v);
        e[u].sz+=e[v].sz;
        if(e[v].sz>e[e[u].son].sz)
          e[u].son=v;
    }
}
inline void dfs2(int u,int top)
{
    e[u].top=top;
    e[u].s=++tot;
    pos[tot]=u;
    if(e[u].son)
    {
        dfs2(e[u].son,top);
        for(int i=head[u];i;i=f[i].next)
        {
            int v=f[i].to;
            if(v!=e[u].fa && v!=e[u].son)
              dfs2(v,v);
        }
    }
    e[u].e=tot;
}
inline void update(int num)
{
    t[num].sum=t[num<<1].sum+t[num<<1|1].sum;
}
inline void ope(int num,int c)
{
    t[num].mark=(t[num].mark+c)%mod;
    t[num].sum=(t[num].sum+(t[num].r-t[num].l+1)*c)%mod;
}
inline void pushdown(int num)
{
    if(t[num].mark)
    {
        if(t[num].l==t[num].r) return;
        ope(num<<1,t[num].mark),ope(num<<1|1,t[num].mark);
        t[num].mark=0;
    }    
}
inline void build(int num,int l,int r)
{
    t[num].l=l,t[num].r=r;
    if(l==r) return;
    int mid=l+r>>1;
    build(num<<1,l,mid);
    build(num<<1|1,mid+1,r);
    update(num);
}
inline void add(int num,int L,int R,int c)
{
    if(L<=t[num].l && t[num].r<=R)
    {
        ope(num,c);return;
    }
    pushdown(num);
    if(L<=t[num<<1].r) add(num<<1,L,R,c);
    if(R>=t[num<<1|1].l) add(num<<1|1,L,R,c);
    update(num);
}
inline int query(int num,int L,int R)
{
    int ans=0;
    if(L<=t[num].l && t[num].r<=R)
      return t[num].sum;
    pushdown(num);
    if(L<=t[num<<1].r) ans=(ans+query(num<<1,L,R))%mod;
    if(R>=t[num<<1|1].l) ans=(ans+query(num<<1|1,L,R))%mod;
    return ans;
}
inline void root(int x)
{
    int f1=e[x].top;
    while(x)
    {
        add(1,e[f1].s,e[x].s,1);
        x=e[f1].fa;f1=e[x].top;
    }
}
inline int find(int x)
{
    int f1=e[x].top;int ans=0;
    while(x)
    {
        ans=(ans+query(1,e[f1].s,e[x].s))%mod;
        x=e[f1].fa;f1=e[x].top;
    }
    return ans;
}
int main()
{
    int i,j,k,x,y,w,l,r,z,fa;
    n=read(),m=read();
    fo(i,2,n)
      fa=read()+1,add(fa,i);
    e[1].dep=1;
    dfs1(1);
    dfs2(1,1);
    build(1,1,n);
    fo(i,1,m)
      q[i].l=read()+1,q[i].r=read()+1,q[i].z=read()+1,q[i].id=i;
    sort(q+1,q+m+1,comp1);k=0;
    fo(i,1,m)
    {
        while(k<q[i].l-1)
          k++,root(k);
        res[q[i].id]=(res[q[i].id]-find(q[i].z))%mod;
    }
    memset(t,0,sizeof t);
    build(1,1,n);
    sort(q+1,q+m+1,comp2);k=0;
    fo(i,1,m)
    {
        while(k<q[i].r)
          k++,root(k);
        res[q[i].id]=(res[q[i].id]+find(q[i].z))%mod;
    }
    fo(i,1,m) printf("%d\n",(res[i]+mod)%mod);
    return 0;
}
/*
5 3
0
0
1
1
0 2 1
0 3 3
0 0 0
*/