[线段树系列] LCT打延迟标记的正确姿势

这一篇博客将教你什么？

如何用LCT打延迟标记，LCT和线段树延迟标记间的关系，为什么延迟标记要这样打。

——正片开始——

学习这一篇博客前，确保你会以下知识：

Link-Cut-Tree，普通线段树

当然，不会也没有关系，你可以先收藏这篇博客，等你学了以后再来看。

最好通过了这一道题：【模板】线段树Ⅱ

没有通过也没关系，对于本篇的知识只是一个启发作用。

我们平时使用的Link-Cut-Tree一般只需要打一个翻转标记rev[x]。

然后我们用pushR(x)函数来下发翻转标记。

那么我们现在来看这样一道题：TreeⅡ

练习LCT打标记的绝世好题，可以说就是一道模板题了。

我们来看它需要维护什么：树的权值。

如果能把这个操作2去掉，树剖将绝杀，可惜换不得。

单走一个“树”，nice，直接LCT。

询问权值和，可以，给LCT来一个下传标记，开始你的操作秀。

我们直接来看pushdown部分：

操作有乘和加两种，根据运算法则，乘法优先，所以首先判断

if(lazM[x]!=1){...}

然后是加法

if(lazA[x]){...}

最后回到我们的翻转标记。

然后我们来看pushM和pushA部分

#define mul(x,y) x*=y;x%=MOD;
inline void pushM(unsigned int x,unsigned int d){
    mul(sum[x],d);mul(val[x],d);//节点信息直接更新
    mul(lazM[x],d);mul(lazA[x],d);//按照运算法则先把乘标记乘了，再把加标记乘了
}

有没有回想起什么？没错，就是线段树的懒标记。

我们看看线段树2的懒标记下传部分

void pushdown(int p){
        mul(p<<1)=(mul(p<<1)*mul(p))%P;
        mul(p<<1|1)=(mul(p<<1|1)*mul(p))%P;
        add(p<<1)=(add(p<<1)*mul(p))%P;
        add(p<<1|1)=(add(p<<1|1)*mul(p))%P;
        sum(p<<1)=(sum(p<<1)*mul(p))%P;
        sum(p<<1|1)=(sum(p<<1|1)*mul(p))%P;//按照运算法则更新标记和节点信息
        mul(p)=1;
        add(p<<1)=(add(p<<1)+add(p))%P;
        add(p<<1|1)=(add(p<<1|1)+add(p))%P;
        sum(p<<1)=(sum(p<<1)+add(p)*(r(p<<1)-l(p<<1)+1))%P;
        sum(p<<1|1)=(sum(p<<1|1)+add(p)*(r(p<<1|1)-l(p<<1|1)+1))%P;//按照运算法则更新标记和节点信息
        add(p)=0;
}

惊人的一致。

猜到pushA的写法了吧？那我不讲了，后面有代码。

透过现象看本质。

两种数据结构都是在维护一个区间，只不过LCT维护的树上一段路径的区间。

如果这道题把操作2去掉，我们用树链剖分写，线段树维护，一样是这样打标记。

为什么？

如果你当初学线段树的时候理解了线段树2打标记里面先成后加的原理，你可能思考一下就明白了。

这里的原因和线段树非常相似：精度。

我们的标记是打在父节点上的，告诉它它的孩子加了多少，乘了多少。

如果我们先加了那么多，再乘那么多，结果是不一样的，如果非要等价，需要对式子变形。

我们看这样一个式子：(a+b)*c，它并不等价于a*c+b，运算的顺序是会影响结果的。

然而我们打标记的时候并不能确定顺序。这时我们为何不用上很早就明白的运算法则呢？

看下面两种顺序：

先+后*：(a+b)*c = a*c+b*c，先*后+：(a+b)*c = a*c+b

我们发现，先+后*的式子并不等于先*后+的式子，要让它相等必须在加的那一项也*上c。

但是要让先*后+的式子转化成先+后*的式子，我们就必须用到除法，就会变成实数运算，还有可能得到无限小数影响精度。所以我们只需要使用先*后+的优先顺序，并且在打乘法标记时把加法标记也乘上这个值就可以了。

分析完后，相信各位应该能理解数据结构“懒标记”的概念以及为何选择这种优先顺序了。

那么剩下的就是很正常的LCT操作了，给出此题的代码。

注意这道题有一个坑点：模数是51061，看上去很小，然而暗藏出题人的心机。

我们来看51061的平方 ——> 2516125921，再看int的数据范围 —— > 2147483647

于是我们需要开long long，但是我写的时候为了卡常用了unsigned int。

#include<bits/stdc++.h>
using namespace std;
int n,q;
const int N=1000010;
#define MOD 51061
unsigned int fa[N],val[N],ch[N][2],rev[N],lazM[N],lazA[N],siz[N],sum[N],stk[N];
#define add(x,y) x+=y;x%=MOD;
#define mul(x,y) x*=y;x%=MOD;
inline unsigned int read(){
    unsigned int data=0,w=1;char ch=0;
    while(ch!=‘-‘ && (ch<‘0‘||ch>‘9‘))ch=getchar();
    if(ch==‘-‘)w=-1,ch=getchar();
    while(ch>=‘0‘ && ch<=‘9‘)data=data*10+ch-‘0‘,ch=getchar();
    return data*w;
}
inline bool chk(unsigned int x){
    return ch[fa[x]][1]==x;
}
inline bool nroot(unsigned int x){
    return ch[fa[x]][0]==x||ch[fa[x]][1]==x;
}
inline void pushup(unsigned int x){
    sum[x]=(sum[ch[x][0]]+sum[ch[x][1]]+val[x])%MOD;
    siz[x]=siz[ch[x][0]]+siz[ch[x][1]]+1;
}
template<class T>inline void fswap(T&x,T&y){
    T t=x;x=y;y=t;
}
inline void pushR(unsigned int x){
    fswap(ch[x][0],ch[x][1]);
    rev[x]^=1;
}
inline void pushM(unsigned int x,unsigned int d){
    mul(sum[x],d);mul(val[x],d);
    mul(lazM[x],d);mul(lazA[x],d);
}
inline void pushA(unsigned int x,unsigned int d){
    add(sum[x],d*siz[x]);add(val[x],d);
    add(lazA[x],d);
}
inline void pushdown(unsigned int x){
    if(lazM[x]!=1){
        pushM(ch[x][0],lazM[x]);
        pushM(ch[x][1],lazM[x]);
        lazM[x]=1;
    }
    if(lazA[x]){
        pushA(ch[x][0],lazA[x]);
        pushA(ch[x][1],lazA[x]);
        lazA[x]=0;
    }
    if(rev[x]){
        if(ch[x][0])pushR(ch[x][0]);
        if(ch[x][1])pushR(ch[x][1]);
        rev[x]=0;
    }
}
inline void rotate(unsigned int x){
    int y=fa[x],z=fa[y],k=chk(x),w=ch[x][k^1];
    ch[y][k]=w;if(w)fa[w]=y;
    if(nroot(y))ch[z][chk(y)]=x;fa[x]=z;
    ch[x][k^1]=y;fa[y]=x;
    pushup(y);pushup(x);
}
inline void splay(unsigned int x){
    int y=x,z=0;
    stk[++z]=y;
    while(nroot(y))stk[++z]=y=fa[y];
    while(z)pushdown(stk[z--]);
    while(nroot(x)){
        y=fa[x];z=fa[y];
        if(nroot(y)){
            if(chk(x)==chk(y))rotate(y);
            else rotate(x);
        }rotate(x);
    }
    pushup(x);
}
inline void access(unsigned int x){
    for(int y=0;x;x=fa[y=x])
        splay(x),ch[x][1]=y,pushup(x);
}
inline void makeroot(unsigned int x){
    access(x);splay(x);
    pushR(x);
}
inline int findroot(unsigned int x){
    access(x);splay(x);
    while(ch[x][0])pushdown(x),x=ch[x][0];
    splay(x);
    return x;
}
inline void split(unsigned int x,unsigned int y){
    makeroot(x);
    access(y);splay(y);
}
inline void link(unsigned int x,unsigned int y){
    makeroot(x);
    if(findroot(y)!=x)fa[x]=y;
}
inline void cut(unsigned int x,unsigned int y){
    makeroot(x);
    if(findroot(y)==x && fa[y]==x && !ch[y][0]){
        fa[y]=ch[x][1]=0;
        pushup(x);
    }
}
int main(){
    n=read();q=read();
    for(int i=1;i<=n;i++)val[i]=siz[i]=lazM[i]=1;
    for(int i=1;i<n;i++){
        int a=read();int b=read();
        link(a,b);
    }
    char opt[10];
    int u,v,d;
    while(q--){
        scanf("%s",opt);
        if(opt[0]==‘+‘){
            u=read();v=read();d=read();
            split(u,v);pushA(v,d);
        }else if(opt[0]==‘-‘){
            u=read();v=read();
            cut(u,v);
            u=read();v=read();
            link(u,v);
        }else if(opt[0]==‘*‘){
            u=read();v=read();d=read();
            split(u,v);pushM(v,d);
        }else{
            u=read();v=read();
            split(u,v);
            printf("%d\n",sum[v]);
        }
    }
    return 0;
}

其实这也揭示了数据结构间的联系：形式不同，作用相似。

透过现象看本质，通过结果推原因，都是学习数据结构的重要方式。

数据结构不只是背背代码，用来加速这么简单的，如果明白了数据结构的运行方式和原理，

你也一定会感慨里面蕴含着的发明者的智慧和它给你带来的知识上的进步。

我是灯塔...一个喜欢数据结构的OIer博主，关注我，我将给你带来更多精彩的文章。

原文地址：https://www.cnblogs.com/light-house/p/11772614.html