[LNOI2014]LCA(树链剖分)

BZOJ传送门

Luogu传送门

题目:给你一棵树，给你n个询问，每个询问要求输出$\sum_{i=l}^{r}depth(LCA(i,z))$

细看看其实没有想象的那么难

大体思路:

1、对于每个询问，考虑打差分变成$\sum_{i=0}^{r}depth(LCA(i,z))-\sum_{i=0}^{l-1}depth(LCA(i,z))$

2、那么这里就是一个思考点了

如何表示$\sum_{i=0}^{p}depth(LCA(i,z))$?

我也不知道

这种时候就该换一个角度思考了

啥是深度?

不就是从根到他有几个点嘛

对于两个点i,j

从i向根的路径上+1

那么$query(root,j)$就是要求的$dep(LCA(i,j))$了

到这里思路就差不多出来了

①把每个询问分成两个，打差分

②排序询问，逐个插入$add(i,root,1)$

③每个询问查出$query(z,root)$

好了答案出来了

#include<cstdio>
#include<algorithm>
using std::sort;
#define mo 201314
)%mo;}
int n,m;
struct sumireko
{
    int to,ne;
}e[];
],ecnt;
void addline(int f,int t)
{
    e[++ecnt].to=t;
    e[ecnt].ne=he[f];
    he[f]=ecnt;
}

],hop[],size[],dson[],llen[],dep[],idn[],idnar;
void dfs1(int x)
{
    size[x]=;
    ;
    for(int i=he[x],t;i;i=e[i].ne)
    {
        t=e[i].to;
        dfs1(t);
        size[x]+=size[t];
        if(lin<size[t])
        {
            lin=size[t];
            dson[x]=t;
        }
    }
}

void dfs2(int x,int top)
{
    idn[x]=++idnar;
    hop[x]=top;
    llen[top]++;
    if(!dson[x]) return;
    dfs2(dson[x],top);
    for(int i=he[x],t;i;i=e[i].ne)
    {
        t=e[i].to;
        if(t==dson[x]) continue;
        dfs2(t,t);
    }
}

struct usami
{
    int f,id,r,z;
    void set(int u,int i,int o,int p){f=u,id=i,r=o,z=p;}
    bool friend operator < (usami a,usami b)
    {
        return a.r<b.r;
    }
}qqq[];
int qcnt;

];

struct segtree
{
    ],del[],size[];
    void build(int px,int pl,int pr)
    {
        if(pl==pr)
        {
            size[px]=;
            return;
        }
        ;
        build(px<<,pl,mid);
        build(px<<|,mid+,pr);
        size[px]=size[px<<]+size[px<<|];
    }
    void fuckup(int px,int pl,int pr)
    {
        if(pl==pr) return;
        v[px]=v[px<<]+v[px<<|];
        MOD(v[px]);
    }
    void fuckdown(int px,int pl,int pr)
    {
        if(pl==pr) return;
        if(del[px])
        {
            v[px<<]+=del[px]*size[px<<];MOD(v[px<<]);
            del[px<<]+=del[px];MOD(del[px<<]);
            v[px<<|]+=del[px]*size[px<<|];MOD(v[px<<|]);
            del[px<<|]+=del[px];MOD(del[px<<|]);
            del[px]=;
        }
    }
    void add(int px,int pl,int pr,int vin,int ql,int qr)
    {
        if(ql<=pl&&qr>=pr)
        {
            v[px]+=vin*size[px];
            del[px]+=vin;
            MOD(v[px]);
            MOD(del[px]);
            return;
        }
        fuckdown(px,pl,pr);
        ;
        ,pl,mid,vin,ql,qr);
        |,mid+,pr,vin,ql,qr);
        fuckup(px,pl,pr);
    }
    int query(int px,int pl,int pr,int ql,int qr)
    {
        if(ql<=pl&&qr>=pr) return v[px];
        fuckdown(px,pl,pr);
        ;
        ;
        ,pl,mid,ql,qr),MOD(ret);
        |,mid+,pr,ql,qr),MOD(ret);
        return ret;
    }
}tr;

void inp(int x)
{
    ])
    {
        tr.add(,,n,,idn[hop[x]],idn[x]);
        x=fa[hop[x]];
    }
    tr.add(,,n,,idn[],idn[x]);
}

void qq(int x,int id,int f)
{
    ;
    ])
    {
        prt+=tr.query(,,n,idn[hop[x]],idn[x]);
        MOD(prt);
        x=fa[hop[x]];
    }
    prt+=tr.query(,,n,idn[],idn[x]);
    MOD(prt);
    ans[id]+=f*prt;
    MOD(ans[id]);
}

int main()
{
    scanf("%d%d",&n,&m);
    ;i<n;i++) scanf("%d",&fa[i]),addline(fa[i],i);
    dep[]=;
    dfs1();
    dfs2(,);
    tr.build(,,n);
    ,lin,rin,zin;i<=m;i++)
    {
        scanf("%d%d%d",&lin,&rin,&zin);
        qqq[++qcnt].,i,lin-,zin);
        qqq[++qcnt].,i,rin,zin);
    }
    sort(qqq+,qqq+qcnt+);
    ;
    ;i<=qcnt;i++)
    {
        while(tinar<qqq[i].r) {tinar++;inp(tinar);}
        qq(qqq[i].z,qqq[i].id,qqq[i].f);
    }
    ;i<=m;i++)
    printf("%d\n",ans[i]);
    ;
}

精污代码慎入