一、延迟标记（懒标记）

在线段树的区间查询命令中，每当遇到被查询区间[l,r]完全覆盖节点时，可以直接把节点上的答案作为备选答案返回。我们已经证明，这样操作的复杂度为O(4logn)。

但是在区间修改命令中，如果某个节点被修改区间完全覆盖，那么以该节点为根的整棵子树都要更新，如果逐一更新，时间复杂度为O（n）

试想，如果我们在一次修改指令中发现节点p代表的区间被修改区间完全覆盖，并更新了所有p子树的节点，但是在之后却没有用到这些答案，那么我们的更新就白费了。

因此，我们在执行修改指令时，如果节点被修改区间完全覆盖，我们可以直接回溯，并且在节点上加一个延迟标记，表示“该节点曾被修改，但其子节点没有被更新”。

如果在后面的操作中，如果需要从p往下递归，我们再检查p是否具有标记。如果有更新p的直接子节点，再在子节点上打上标记，然后清除p的标记。

也就是说，除了在修改指令中直接划分成的O(logn)个结点外，对任意节点的修改都延迟到“在后续操作递归进入它的父节点”时进行。这样一来，查询和修改的时间复杂度都是O（logn）级别。

例题1：一个简单的整数问题2

本题之前用树状数组和差分结合解决过。这里再介绍线段树懒标记做法。

更新懒标记需要用到pushdown函数。（与pushup函数对应）

推导区间和的懒标记pushdown的转移方程：将懒标记加到子节点的标记上，子节点的sum加上子节点区间长度*懒标记。最后清空父节点懒标记

$left.add+=root.add,right.add+=root.add;$

$left.sum+=(LL)(left.r-left.l+1)*root.add;$ $right.sum+=(LL)(right.r-right.l+1)*root.add;$

$root.add=0;$

完整代码：

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N =1e5+10;
typedef long long LL;

int n,m;
int w[N];
struct Node{
    int l,r;
    LL sum,add;
}tr[4*N];

void pushup(int u)
{
    tr[u].sum=tr[u<<1].sum+tr[u<<1|1].sum;
}
void pushdown(int u)
{
    auto &root=tr[u],&left=tr[u<<1],&right=tr[u<<1|1];
    if(root.add)
    {
        left.add+=root.add,right.add+=root.add;
        left.sum+=(LL)(left.r-left.l+1)*root.add;
        right.sum+=(LL)(right.r-right.l+1)*root.add;
        root.add=0;
    }

}

void build(int u,int l,int r)
{
    if(l==r) tr[u]={l,r,w[l],0};
    else
    {
        tr[u]={l,r};
        int mid=l+r>>1;
        build(u<<1,l,mid),build(u<<1|1,mid+1,r);
        pushup(u);
    }
}

void modify(int u,int l,int r,int d)
{
    if(tr[u].l>=l&&tr[u].r<=r)
    {
        tr[u].sum+=(LL)(tr[u].r-tr[u].l+1)*d;
        tr[u].add+=d;
    }
    else
    {
        pushdown(u);
        int mid=tr[u].l+tr[u].r>>1;
        if(l<=mid) modify(u<<1,l,r,d);
        if(r>mid) modify(u<<1|1,l,r,d);
        pushup(u);
    }

}
LL query(int u,int l,int r)
{
    if(tr[u].l>=l&&tr[u].r<=r) return tr[u].sum;
    pushdown(u);
    int mid=tr[u].l+tr[u].r>>1;
    LL sum=0;
    if(l<=mid) sum+=query(u<<1,l,r);
    if(r>mid) sum+=query(u<<1|1,l,r);
    return sum;
}

int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>w[i];
    build(1,1,n);
    char op[2];
    int l,r,d;

    while(m--)
    {
        cin>>op>>l>>r;
        if(*op=='C')
        {
            cin>>d;
            modify(1,l,r,d);
        }
        else
        {
            cout<<query(1,l,r)<<endl;
        }
    }
    return 0;
}

作者：yankai
链接：https://www.acwing.com/activity/content/code/content/5209661/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

例题2：1277. 维护序列

处理操作多了一个将区间内每个数乘以一个值。

懒标记处理更加复杂了，对此，我们需要两个懒标记来表示一个操作。一个mul，一个add。

对每一个操作，我们可以把之归为一类操作，即：把区间乘一个数再加一个数，或者把区间加一个数再乘一个数。显然选择抽象成把区间乘一个数再加一个数更为方便。

因为如果要把区间加一个数d，我们可以直接归类为：把区间乘1再加d。

如果把区间乘一个数d，可以归类为：把区间乘d再加0。不需要多余的转化。

因此我们的懒标记pushdown方法方程为：

void eval(Node &t, int add, int mul)
{
    t.sum = ((LL)t.sum * mul + (LL)(t.r - t.l + 1) * add) % p;
    t.mul = (LL)t.mul * mul % p;
    t.add = ((LL)t.add * mul + add) % p;
}
void pushdown(int u)
{
    eval(tr[u<<1],tr[u].add,tr[u].mul);
    eval(tr[u<<1|1],tr[u].add,tr[u].mul);
    tr[u].add=0,tr[u].mul=1;
}

大体框架不变，完整代码为：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
using namespace std;

const int N =1e6+10;
typedef long long LL;

int n,p,m;
int w[N];
struct Node{
    int l,r;
    LL sum,add,mul;
}tr[N*4];

void pushup(int u)
{
    tr[u].sum=(tr[u<<1].sum+tr[u<<1|1].sum)%p;
}

void eval(Node &t, int add, int mul)
{
    t.sum = ((LL)t.sum * mul + (LL)(t.r - t.l + 1) * add) % p;
    t.mul = (LL)t.mul * mul % p;
    t.add = ((LL)t.add * mul + add) % p;
}
void pushdown(int u)
{
    eval(tr[u<<1],tr[u].add,tr[u].mul);
    eval(tr[u<<1|1],tr[u].add,tr[u].mul);
    tr[u].add=0,tr[u].mul=1;
}
void build(int u,int l,int r)
{
    if(l==r) tr[u]={l,r,w[r],0,1};
    else
    {
        tr[u]={l,r,0,0,1};
        int mid=l+r>>1;
        build(u<<1,l,mid),build(u<<1|1,mid+1,r);
        pushup(u);
    }
}
void modify(int u,int l,int r,int add,int mul)
{
    if(tr[u].l>=l&&tr[u].r<=r)  eval(tr[u],add,mul);
    else
    {
        pushdown(u);
        int mid=tr[u].l+tr[u].r>>1;
        if(l<=mid) modify(u<<1,l,r,add,mul);
        if(r>mid) modify(u<<1|1,l,r,add,mul);
        pushup(u);
    }
}

int query(int u,int l,int r)
{
    if(tr[u].l>=l&&tr[u].r<=r) return tr[u].sum;
    else
    {
        pushdown(u);
        int mid=tr[u].l+tr[u].r>>1;
        int sum=0;
        if(l<=mid) sum=query(u<<1,l,r);
        if(r>mid) sum=(sum+query(u<<1|1,l,r))%p;
        return sum;
    }
}

int main()
{
    cin>>n>>p;
    for(int i=1;i<=n;i++) cin>>w[i];
    build(1,1,n);
    cin>>m;
    while(m--)
    {
        int t,l,r,d;
        cin>>t>>l>>r;
        if(t==1)
        {
            cin>>d;
            modify(1,l,r,0,d);
        }
        else if(t==2)
        {
            cin>>d;
            modify(1,l,r,d,1);
        }
        else cout<<query(1,l,r)<<endl;
    }
    return 0;
}

作者：yankai
链接：https://www.acwing.com/activity/content/code/content/5260636/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

二、线段树+扫描线+二分查找+离散化

【hdu1542】线段树求矩形面积并 - 拦路雨偏似雪花 - 博客园 (cnblogs.com)

本人理解不到位，以后在补owo

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
#include<cstdio>
#include<vector>

const int N =1e5+10;

int n;
struct Segment{
    double x,y1,y2;
    int k;
    bool operator <(const Segment &t)const
    {
        return x<t.x;
    }
}seg[2*N];

struct Node{
    int l,r;
    int cnt;
    double len;
}tr[4*2*N];

vector<double> ys;

int find(double y)
{
    // 需要返回vector 中第一个 >= y 的数的下标
    return lower_bound(ys.begin(), ys.end(), y) - ys.begin();
}

void pushup(int u)
{
    if(tr[u].cnt)   tr[u].len=ys[tr[u].r+1]-ys[tr[u].l];
    else if(tr[u].l!=tr[u].r)
    {
        tr[u].len = tr[u << 1].len + tr[u << 1 | 1].len;
    }
    else tr[u].len = 0;//表示为叶子节点且该线段没被覆盖，为无用线段，长度变为0
}

void modify(int u,int l,int r,int d)
{
    if(tr[u].l >= l && tr[u].r <= r)//该区间被完全覆盖
    {
        tr[u].cnt += d;//该区间出现次数 + d
        pushup(u);//更新该节点的len
    }
    else
    {
        int mid = tr[u].r + tr[u].l >> 1;
        if (l <= mid)modify(u << 1,l,r,d);//左边存在点
        if (r > mid)modify(u << 1 | 1,l,r,d);//右边存在点
        pushup(u);//进行更新
    }
}
void build(int u,int l,int r)
{
    tr[u] = {l,r,0,0};

    if (l != r)
    {
        int mid = l + r >> 1;
        build(u << 1,l,mid),build(u << 1 | 1,mid + 1,r);
        //后面都为0，不需更新len
    }
}

int main()
{
    int T=1;
    while(scanf("%d",&n),n)
    {
        ys.clear();
        for(int i=0,j=0;i<n;i++)
        {
            double x1,y1,x2,y2;
            scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
            seg[j ++ ] = {x1, y1, y2, 1};
            seg[j ++ ] = {x2, y1, y2, -1};
            ys.push_back(y1), ys.push_back(y2);   
        }
        sort(ys.begin(),ys.end());
        ys.erase(unique(ys.begin(),ys.end()),ys.end());
        build(1,0,ys.size()-2);
        sort(seg,seg+2*n);
        double res=0;
        for(int i=0;i<n*2;i++)
        {
            if(i>0) res+=tr[1].len*(seg[i].x-seg[i-1].x);
            modify(1, find(seg[i].y1), find(seg[i].y2) - 1, seg[i].k);
        }

        printf("Test case #%d\n", T ++ );
        printf("Total explored area: %.2lf\n\n", res);

    }
    return 0;

}

作者：yankai
链接：https://www.acwing.com/activity/content/code/content/5257208/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/169541.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！