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;

以上就是线段树基础操作啦。
往下的内容将记录线段树相对进阶的应用。
(但是你真的以为线段树基础操作只局限于这一点点东西吗???(笑
对于上述内容的一些补充:线段树常用技巧模版(刷题篇)

###进阶应用

一、扫描线

P5490 【模板】扫描线

扫描线的思想与与微积分类似,都是将不规则的图形转化成规则的图形来求面积。
比如这个例题,要求出所有矩形面积的并,那么就是要求一个不规则图形的面积,如图所示:

那么可以通过每个矩形的边界,将图形分割成若干块,每块都是一个规则的矩形。

这样一来,只需要查询对于每个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 重见线段树的主要内容,如果未能解决你的问题,请参考以下文章

线段树常用技巧模版(刷题篇)

线段树常用技巧模版(刷题篇)

线段树 建树 单点修改 点点/区间查询

HDU 5669 Road(线段树建树)(分层图最短路)

POJ - 3321 Apple Tree (线段树 + 建树 + 思维转换)

线段树--从入门到入土入门篇:没有pushdown的简单建树&查询&修改(单点+区间)