参考-《算法竞赛进阶指南》
一、延迟标记（懒标记）
在线段树的区间查询命令中，每当遇到被查询区间[l,r]完全覆盖节点时，可以直接把节点上的答案作为备选答案返回。我们已经证明，这样操作的复杂度为O(4logn)。
但是在区间修改命令中，如果某个节点被修改区间完全覆盖，那么以该节点为根的整棵子树都要更新，如果逐一更新，时间复杂度为O（n）
试想，如果我们在一次修改指令中发现节点p代表的区间被修改区间完全覆盖，并更新了所有p子树的节点，但是在之后却没有用到这些答案，那么我们的更新就白费了。
因此，我们在执行修改指令时，如果节点被修改区间完全覆盖，我们可以直接回溯，并且在节点上加一个延迟标记，表示“该节点曾被修改，但其子节点没有被更新”。
如果在后面的操作中，如果需要从p往下递归，我们再检查p是否具有标记。如果有更新p的直接子节点，再在子节点上打上标记，然后清除p的标记。
也就是说，除了在修改指令中直接划分成的O(logn)个结点外，对任意节点的修改都延迟到“在后续操作递归进入它的父节点”时进行。这样一来，查询和修改的时间复杂度都是O（logn）级别。
例题1：一个简单的整数问题2
本题之前用树状数组和差分结合解决过。这里再介绍线段树懒标记做法。
更新懒标记需要用到pushdown函数。（与pushup函数对应）
推导区间和的懒标记pushdown的转移方程：将懒标记加到子节点的标记上，子节点的sum加上子节点区间长度*懒标记。最后清空父节点懒标记
完整代码：
#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
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
3046
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
