线段树的lazy标记

众所周知，当涉及到线段树的区间修改时，往往会引入lazy标记，通过懒惰标记的push_down优化区间修改和查询

如这道板题:　　题目链接

#include <bits/stdc++.h>
#define Lson(x) ((x)<<1)
#define Rson(x) ((x)<<1|1)
using namespace std;

const int maxn =1e5;
int d[(maxn<<2)+10];
int lazy[(maxn<<2)+10];
int raw[maxn+10];
void build(int s,int t,int p){
    if(s==t){
        d[p] = raw[s];
        return;
    }
    int mid = (s+t)>>1;
    build(s,mid,Lson(p));
    build(mid+1,t,Rson(p));
    d[p] = d[Lson(p)] + d[Rson(p)];
    return;
}

void update(int L,int R,int C,int s,int t,int p){
    if(L==s&&t==R){
        d[p] = (R-L+1)*C;
        lazy[p] = C;
        return ;
    }

    int mid = (s+t)>>1;

    if(lazy[p]&&s!=t){//not leaf node and lazy
        d[Lson(p)] = (mid - s + 1 )*lazy[p];lazy[Lson(p)] = lazy[p];
        d[Rson(p)] = (t - mid)*lazy[p];lazy[Rson(p)] = lazy[p];
        lazy[p] = 0;
    }

    if(R<=mid) update(L,R,C,s,mid,Lson(p));
    else if(L>mid) update(L,R,C,mid+1,t,Rson(p));
    else update(L,mid,C,s,mid,Lson(p)) , update(mid+1,R,C,mid+1,t,Rson(p));
    d[p] = d[Lson(p)] + d[Rson(p)];
}

int query(int L,int R,int s,int t,int p){
    if(L==s&&t==R){
        return d[p];
    }

    int mid = (s+t)>>1;
    if(lazy[p]&&s!=t){
        d[Lson(p)] = (mid - s + 1 )*lazy[p];lazy[Lson(p)] = lazy[p];
        d[Rson(p)] = (t - mid)*lazy[p];lazy[Rson(p)] = lazy[p];
        lazy[p] = 0;
    }

    int sum = 0;
    if(R<=mid) sum+=query(L,R,s,mid,Lson(p));
    else if(L>mid) sum+=query(L,R,mid+1,t,Rson(p));
    else sum = query(L,mid,s,mid,Lson(p)) + query(mid+1,R,mid+1,t,Rson(p));
    return sum;
}

int main(){
    int N;
    scanf("%d",&N);
    for(int i=1;i<=N;++i){
        scanf("%d",&raw[i]);
    }
    build(1,N,1);
    int Q;
    scanf("%d",&Q);
    for (int i = 0; i < Q; ++i) {
        int op;
        scanf("%d",&op);
        if(op) {
            int L,R,C;
            scanf("%d%d%d",&L,&R,&C);
            update(L,R,C,1,N,1);
        } else {
            int L,R;
            scanf("%d%d",&L,&R);
            printf("%d
",query(L,R,1,N,1));
        }
    }
    return 0;
}

而关于lazy标记，还有一种标签永久化的思路，还是一道板题:　　题目链接

 这道题当然可以用正常的下推lazy标记写，但如果我们想标记永久化，减少下推过程也是可以做的。

update部分搜到一点只改标签，然后改一路以来的 d[] 结点值（这点很重要，不然查询时，查到一个中间点可能结束，曾经对其后代的修改就丢失了）。query部分搜索时同时用ever记录一路以来的lazy标记值之和，ever其实就是应该增加却没有用过的值，搜到中间返回时计算区间和（d[]结点值，lazy标记与ever）。此题 lazy标记怎么加也不会爆int，但区间和可能会爆int。

//#include <bits/stdc++.h>
#include <cstdio>
using namespace std;
#define Lson(x) ((x)<<1)
#define Rson(x) ((x)<<1|1)
typedef long long ll;
const int maxn = 1e5;
ll d[(maxn<<2)+10];
int lazy[(maxn<<2)+10];
int raw[maxn+10];

void build(int s,int t,int p){
    if(s==t){
        d[p] = 1ll*raw[s];
        lazy[p] = 0;
        return ;
    }
    int mid = (s+t) >> 1;
    build(s,mid,Lson(p));
    build(mid+1,t,Rson(p));
    lazy[p] = 0;
    d[p] = d[Lson(p)] + d[Rson(p)];
}

void update(int L,int R, int C, int s,int t,int p){
    if(L==s && t==R){
        lazy[p] += 1ll*C;
        return ;
    }

    d[p] += 1ll*(R-L+1)*C;//这一句保证当前点接受对其后代的修改

    int mid = (s+t) >> 1;
    if(R<=mid)
        update(L,R,C,s,mid,Lson(p));
    else if(L>mid)
        update(L,R,C,mid+1,t,Rson(p));
    else update(L,mid,C,s,mid,Lson(p)) , update(mid+1,R,C,mid+1,t,Rson(p));
}

ll query(int L,int R,int s,int t,int p,int ever){
    if(L==s && t==R){
        return 1ll*d[p] + 1ll*(t-s+1) * (lazy[p] + ever);
    }
    int mid = (s+t)>>1;
    ll sum = 0;
    if(R<=mid) sum += query(L,R,s,mid,Lson(p),ever + lazy[p]);
    else if(L>mid) sum += query(L,R,mid+1,t,Rson(p),ever + lazy[p]);
    else sum = query(L,mid,s,mid,Lson(p),ever + lazy[p]) + query(mid+1,R,mid+1,t,Rson(p),ever + lazy[p]);
    return sum;
}

int main(){
    int N,Q;
    while(~scanf("%d%d",&N,&Q)){
        for (int i = 1; i <= N; ++i) {
            scanf("%d",&raw[i]);
        }
        build(1,N,1);
        for (int i = 0; i < Q; ++i) {
            char op[3];
            scanf("%s",op);
            if(op[0] == 'Q'){
                int a, b;
                scanf("%d%d",&a,&b);
                printf("%lld
",query(a,b,1,N,1,0));
            }
            else{
                int a,b,c;
                scanf("%d%d%d",&a,&b,&c);
                update(a,b,c,1,N,1);
            }
        }
    }
    return 0;
}

d[p] += 1ll*(R-L+1)*C;//这一句保证当前点接受对其后代的修改

开始少了这句相当于丢掉了许多修改，因为query是会搜到一半就结束的，没有pushdown和maitain就需要修改一路以来的值。

关于标签永久化，再请看这题:　　题目链接

题意是一个长为 n 的序列 a[n](下标1~n)  ，初始时每个元素为0，现在有m次操作L , R ,V将区间[L, R]里小于V的元素更新为V，最后询问每个 ai * i 的异或和。这道题的输入是根据三个初始数字和一个函数不断生成的，可以看做是随机的区间修改。(n<=1e5,m<=5e6)

“区间[L, R]里小于V的元素更新为V”那肯定是有的元素更新有的不更新，而最后的询问是每个元素的值都用上了，值得注意的是只有一个询问。

于是我们可以采用lazy标记永久化的思路，每一次区间修改中没有标记的push_down也没有maintain，只是单纯地更新区间lazy标记（如此线段树只需要存lazy标记），而在最后的查询里DFS搜到底部的过程中，我们只需要记录一路走到该点的最大标记值，然后计算对答案贡献即可。之前打标记复杂度是O(mlogn)　最后DFS遍历所有点O(nlogn)。

#include <bits/stdc++.h>
#define Lson(x) ((x)<<1)
#define Rson(x) ((x)<<1|1)
using namespace std;

const int maxn = 1e5;
const unsigned int mod = 1<<30;
//const pair<int ,int > KONG = make_pair(0,0);
unsigned X,Y,Z;
//int d[(maxn<<2)+10];
int lazy[(maxn<<2)+10];
long long ans;
unsigned int RNG61(){
    X = X^(X<<11);
    X = X^(X>>4);
    X = X^(X<<5);
    X = X^(X>>14);
    unsigned W = X ^(Y ^ Z);
    X = Y;
    Y = Z;
    Z = W;
    return Z;
}

void build(int s,int t,int p){
    if(s==t){
//        d[p] = 0;
        lazy[p] = 0;
        return ;
    }
    int mid = (s+t)>>1;
    build(s,mid,Lson(p));
    build(mid+1,t,Rson(p));
//    d[p] = 0;
    lazy[p] = 0;
    return;
}

void update(int L,int R,int C,int s,int t,int p){
    if(C < lazy[p]) return;//根本不用往下搜,剪枝

    if(L==s && R==t){
        lazy[p] = max(lazy[p],C);
        return ;
    }
    int mid = (s+t) >> 1;
    if(R<=mid) update(L,R,C,s,mid,Lson(p));
    else if(L>mid) update(L,R,C,mid+1,t,Rson(p));
    else update(L,mid,C,s,mid,Lson(p)),update(mid+1,R,C,mid+1,t,Rson(p));
}


void DFS(int s,int t,int p,int tmax){
   tmax = max(lazy[p],tmax);
   if(s==t){
//       printf("%d :%d
",s,tmax);
       ans ^= 1ll*s*tmax;
       return;
   }
   int mid = (s+t)>>1;
   DFS(s,mid,Lson(p),tmax);
   DFS(mid+1,t,Rson(p),tmax);
   return ;
}

int main(){
//    __clock_t stt = clock();
    int T;
    cin >> T;
    while(T--){
        int N,M;
        cin >> N >> M >> X >> Y >> Z;
        unsigned int n = static_cast<unsigned int>(N);
        build(1,N,1);
        for(int i=1;i<=M;++i){
            unsigned int f1 = RNG61();
            unsigned int f2 = RNG61();
            unsigned int f3 = RNG61();
            int L = (f1 % n) + 1;
            int R = (f2 % n) + 1;
            int V = f3 % (1<<30);
            update(min(L,R),max(L,R),V,1,N,1);
        }
        ans = 0;
        DFS(1,N,1,0);
        printf("%lld
",ans);
    }
//    __clock_t ent = clock();
//    printf("Used Time: %.3lf", static_cast<double>(ent - stt)/1000.0);
    return 0;
}

开始写的还是TLE了，自己测了测时间大概20秒，DFS遍历所有点是必须的，那么其实可以在打标记时进行剪枝优化:

if(C < lazy[p]) return;//根本不用往下搜,剪枝

当前区间的lazy标记值已经大于修改值C，那么这个lazy标记将会覆盖C的影响，所以没有必要往下方更新。

最后2秒通过，随机数据还是能剪枝不少。