2021-07-27 重见线段树
Posted KaaaterinaX
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了2021-07-27 重见线段树相关的知识,希望对你有一定的参考价值。
###基础操作
引入:
线段树是一种神奇的数据结构,支持在线高效率(lgn)区间/单点修改/查询。下面用一个经典例题引入线段树基本模版。
————————————————————————————————
有一个长度为n(n<=1e5)的数组,有m(m<=1e5)次操作,操作涉及修改数组中某个元素的值以及查询数组连续区间内的和。
————————————————————————————————
这个题如果把数据量缩小,就是一个简单暴力题,但是数据量上来了,就需要用到线段树了。
随便揪一张图片:
这个图可以很好地展示线段树为什么可以高效率查询区间信息。
一、基础建树
const int maxn=1e5+7;
int a[maxn];
struct node
int l,r;
int sum;
tr[maxn*4];
void build(int u,int l,int r)
tr[u].l=l;
tr[u].r=r;
if(l==r)
//叶节点
tr[u].sum=a[l];
return;
int mid=(l+r)>>1;
build(u<<1,l,mid);
build(u<<1|1,mid+1,r);
tr[u].sum=tr[u<<1].sum+tr[u<<1|1].sum;
int main()
build(1,1,n);//主函数中调用建树函数时,传入参数依次为:根节点,左区间,右区间
二、单点修改,区间查询
修改:
void modify(int u,int x,int d)
//把编号为x的节点加上d,也是从更节点开始向下寻找
if(tr[u].l==tr[u].r&&tr[u].l==x)
tr[u].sum+=d;
return;
int mid=(tr[u].l+tr[u].r)>>1;
if(x<=mid)
modify(u<<1,x,d);
else
modify(u<<1|1,x,d);
tr[u].sum=tr[u<<1].sum+tr[u<<1|1].sum;//pushup,由更新了的子节点更新父节点
查询:
int query(int u,int l,int r)
//从根节点开始,向下寻找符合条件的线段树节点
if(tr[u].l>=l&&tr[u].r<=r)
//如果节点区间包含在查询区间内
return tr[u].sum;
else if(tr[u].l>r||tr[u].r<l)
//如果节点区间与查询没有交集
return 0;
else
//如果查询区间与节点有交集
int s=0;
s+=query(u<<1,l,r);
s+=query(u<<1|1,l,r);
return s;
运用以上的三个模版,就可以轻松解决「引入」中的问题啦!
但是线段树的应用方法远不止于此,接下来继续介绍其它线段树模版。
再引入一个题:
——————————————————————————————————————
P3372 【模板】线段树 1
——————————————————————————————————————
如果对区间中每个点都做区间单点修改,那么复杂度甚至比暴力模拟还要高。那怎么办?这就要用到线段树另外一种操作——延迟修改技术(lazytag)。
基本原理就是,只要不需要查询带tag的子区间,这个tag就不会下传更新,这样可以大大节省时间。
三、区间修改(lazytag)
修改:
void pushdown(ll u)
if(tag[u]!=0)
//更新子节点信息
tr[u<<1].sum+=(tr[u<<1].r-tr[u<<1].l+1)*tag[u];
tr[u<<1|1].sum+=(tr[u<<1|1].r-tr[u<<1|1].l+1)*tag[u];
//下传懒标记
tag[u<<1]+=tag[u];
tag[u<<1|1]+=tag[u];
tag[u]=0;//父节点懒标记归0
void modify(ll u,ll l,ll r,ll k)
//把[l,r]区间内元素加上k
if(tr[u].l>=l&&tr[u].r<=r)
tag[u]+=k;
tr[u].sum+=k*(tr[u].r-tr[u].l+1);
return;
if(tr[u].l>r||tr[u].r<l)
return;
pushdown(u);//要先把父节点原有到懒标记下传
modify(u<<1,l,r,k);
modify(u<<1|1,l,r,k);
tr[u].sum=tr[u<<1].sum+tr[u<<1|1].sum;//因为到懒标记确定位置,节点信息才会被更新,所以需要依此更新父节点
查询:
ll query(ll u,ll l,ll r)
ll sum=0;
if(l<=tr[u].l&&r>=tr[u].r)
sum+=tr[u].sum;
return sum;
if(l>tr[u].r||r<tr[u].l)
return 0;
else
pushdown(u);//下传懒标记
sum+=query(u<<1,l,r);
sum+=query(u<<1|1,l,r);
return sum;
以上就是线段树基础操作啦。
往下的内容将记录线段树相对进阶的应用。
(但是你真的以为线段树基础操作只局限于这一点点东西吗???(笑
对于上述内容的一些补充:线段树常用技巧模版(刷题篇)
###进阶应用
一、扫描线
扫描线的思想与与微积分类似,都是将不规则的图形转化成规则的图形来求面积。
比如这个例题,要求出所有矩形面积的并,那么就是要求一个不规则图形的面积,如图所示:
那么可以通过每个矩形的边界,将图形分割成若干块,每块都是一个规则的矩形。
这样一来,只需要查询对于每个X节点,对应y覆盖的长度是多少。
于是就引出线段树啦!
(差不多也就是个线段树区间修改)
记录每个X对应的y1,y2(y轴上下界)
从左往右扫过去,遇到的X如果对应某个矩形左边的边,那么说明从这个位置开始,之后的一段内[y1,y2]都是被覆盖的,tag=1,如果X对应的右边的边,tag=-1。
因为本题y的范围很大,所以需要进行离散化,所以线段树操作会有一些细节跟普通的有点区别。
//线段树扫描线
//毒瘤题目,还要离散化。。
#define int ll//必须开ll,一开始写了很多的int所以这次骚一波了
const int maxn=1e5+7;
struct seg
int x;
int y1,y2;
int k;
bool operator< (const seg &t)const
return x<t.x;
sg[maxn<<1];//记录线段
//离散化模块
vector<int> y;
int find(int yy)
return (int)(lower_bound(y.begin(),y.end(),yy)-y.begin());
//线段树模块
struct node
int cnt;//记录这个区间被整体覆盖的次数
int len;//记录这个区间被标记长度
int l,r;
tr[maxn<<2];
void pushup(int u)
if(tr[u].cnt)
tr[u].len=y[tr[u].r+1]-y[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;
void build(int u,int l,int r)
tr[u].l=l;
tr[u].r=r;
if(l==r)
return;
int mid=(l+r)>>1;
build(u<<1,l,mid);
build(u<<1|1,mid+1,r);
void modify(int u,int l,int r,int k)
if(l<=tr[u].l&&r>=tr[u].r)
tr[u].cnt+=k;
pushup(u);
//必须及时pushup,因为懒标记不会下传
return;
if(l>tr[u].r||r<tr[u].l)
return;
else
modify(u<<1,l,r,k);
modify(u<<1|1,l,r,k);
pushup(u);
signed main()
int n;
cin>>n;
int cnt=0;
for(int i=1;i<=n;i++)
int x1,x2,y1,y2;
cin>>x1>>y1>>x2>>y2;
sg[++cnt]=x1,y1,y2,1;
sg[++cnt]=x2,y1,y2,-1;
y.pb(y1);
y.pb(y2);
sort(y.begin(),y.end());
y.erase(unique(y.begin(),y.end()),y.end());
build(1,0,(int)y.size()-2);
sort(sg+1,sg+cnt+1);
ll res=0;
for(int i=1;i<=cnt;i++)
if(i>1)
res+=tr[1].len*(sg[i].x-sg[i-1].x);
modify(1,find(sg[i].y1),find(sg[i].y2)-1,sg[i].k);
cout<<res<<endl;
return 0;
以上是关于2021-07-27 重见线段树的主要内容,如果未能解决你的问题,请参考以下文章