线段树入门&lazy思想

最新推荐文章于 2023-05-11 21:23:17 发布
置顶 最新推荐文章于 2023-05-11 21:23:17 发布
阅读量9.4k 收藏 167
点赞数 60
分类专栏： 算法入门系列 文章标签： 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012469987/article/details/41357377
版权

线段树将区间分成若干个子区间，子区间又继续分，直到区间为一个点（区间左值等于右值）

对于父区间[a,b]，其子区间为[a,(a+b)/2]和[(a+b)/2+1,b] 

用于求区间的值，如区间最值、区间的和等。

代码实现中，约定结点下标从1开始，所以某结点下标为x，那么左儿子下标为2x，右儿子下标为2x+1，父结点下标为x/2。



常用符号
符号等价意义
rt<<1rt*2左子树的编号
rt<<1|1
rt*2+1右子树的编号
 (l+r)>>1
(l+r)/2区间长度的一半


常用宏定义

#define Mid ((l+r)>>1)      	//注意括号
#define lson rt<<1,l,Mid	//左结点
#define rson rt<<1|1,Mid+1,r	//右结点


建树

建树丛根结点开始，递归建立左右子树，直到叶子结点，然后反向赋值，父结点的值 = F(左结点的值，右结点的值），这个F是依据题意变的，如果是区间最大则为max()

void build(int rt,int l,int r)      //建编号为rt的区间为[l,r]的树，主函数传进来的固定是(1,1,n)
{
    if(l==r){            //叶子结点赋初值，注意下标，Max的是编号，val原数组的是l，看图可以理解
        Max[rt] = val[l];
    }else{                      //建左右子树
        build(lson);
        build(rson);
        Max[rt] = max( Max[rt<<1], Max[rt<<1|1]);   //父结点Max值为Max(左子结点，右子结点）
    }
}


查询

查询为区间查询（只是查询某个点的话不需要线段树），即在区间里查询某个特性值，每次查询都是从跟结点开始往下，根据查询区间和当前区间的区间位置判断是要去左右子区间查询，还是直接返回。如果被查询区间是查询区间的子区间则直接返回子区间的值，如在[1,6]里查询[1,12]就返回[1,6]的值，不再往下查询。 
void query(int rt,int l,int r,int L,int R)  //在[l,r]里查询[L,R]的值，[L,R]一直不变，[l,r]变
{
    if(L <= l && r <= R){   
        ans1 = max(ans1,Max[rt]);
        ans2 = min(ans2,Min[rt]);
    }else{
        if( L <= Mid) //查询区间在当前区间的左半区间有内容，如在[1,6]里查询[2,3]
            query(lson,L,R);    
        if( R > Mid)  //同理去右子区间，注意不能有else，因为有横跨左右的情况，如[1,6]里查询[2,5]
            query(rson,L,R);
    }
}


更新

更新分为单点更新和区间更新，区间更新等会在下面讲述，而单点更新跟普通区间查询差不多

void update(int rt,int l,int r,int pos,int num)
{
    if(l == r && r == pos){     //到对应的叶结点
        Max[rt] = num;
    }else{
        if( pos <= Mid)
            update(lson,pos,num);
        if( pos > Mid)          //或者直接else，点不可能同时在两个区间里
            update(rson,pos,num);
        Max[rt] = max( Max[rt<<1], Max[rt<<1|1]);
    }
}

数组大小要为原数据范围的4倍，证明点这里

题目

POJ 3264 Balanced Lineup 求区间的最大值-最小值

#include <cstdio>
#include <cmath>
#include <iostream>
using namespace std;
#define FOR( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define RE freopen("1.in","r",stdin);
#define bug(x) cout<<#x<<":"<<(x)<<endl;

#define Mid ((l+r)>>1)      //括号！
#define lson rt<<1,l,Mid
#define rson rt<<1|1,Mid+1,r

const int maxn= 50005;
const int inf=0x3f3f3f3f;
int Max[maxn<<2],Min[maxn<<2];
int ans1,ans2;

void build(int rt,int l,int r)
{
    if(l==r){
        scanf("%d",&Max[rt]);
        Min[rt] = Max[rt];
    }else{
        build(lson);
        build(rson);
        Max[rt] = max( Max[rt<<1], Max[rt<<1|1]);
        Min[rt] = min( Min[rt<<1], Min[rt<<1|1]);
    }
}

void query(int rt,int l,int r,int L,int R)
{
    if(L <= l && r <= R){
        ans1 = max(ans1,Max[rt]);
        ans2 = min(ans2,Min[rt]);
    }else{
        if( L <= Mid)
            query(lson,L,R);
        if( R > Mid)
            query(rson,L,R);
    }
}

int main()
{
    int n,m,L,R;
    while(scanf("%d%d",&n,&m)!=EOF){
        build(1,1,n);
        while(m--){
            ans1 = -inf,ans2 = inf;
            scanf("%d%d",&L,&R);
            query(1,1,n,L,R);
            printf("%d\n", ans1-ans2);
        }
    }
    return 0;
}


HDU 1754  I Hate It单点更新，区间查询最大

#include <cstdio>
#include <cmath>
#include <iostream>
using namespace std;
#define FOR( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define RE freopen("1.in","r",stdin);
#define bug(x) cout<<#x<<":"<<(x)<<endl;

#define Mid ((l+r)>>1)     
#define lson rt<<1,l,Mid
#define rson rt<<1|1,Mid+1,r

const int maxn= 200000+5;
const int inf=0x3f3f3f3f;
int Max[maxn<<2];
int ans1,ans2;

void build(int rt,int l,int r)
{
    if(l==r){
        scanf("%d",&Max[rt]);
    }else{
        build(lson);
        build(rson);
        Max[rt] = max( Max[rt<<1], Max[rt<<1|1]);
    }
}
void update(int rt,int l,int r,int pos,int num)
{
    if(l == r && r == pos){
        Max[rt] = num;
    }else{
        if( pos <= Mid)
            update(lson,pos,num);
        if( pos > Mid)
            update(rson,pos,num);
        Max[rt] = max( Max[rt<<1], Max[rt<<1|1]);
    }
}
int query(int rt,int l,int r,int L,int R)
{
    if(L <= l && r <= R){
        return Max[rt];
    }else{
        int tmp = -1;
        if( L <= Mid)
            tmp = max(tmp,query(lson,L,R));
        if( R > Mid)
            tmp = max(tmp,query(rson,L,R));
        return tmp;
    }
}

int main()
{
//    RE
    int n,m,L,R;
    char op;
    while(scanf("%d%d",&n,&m)!=EOF){
        build(1,1,n);
        getchar();
        while(m--){
            scanf("%c%d%d%*c",&op,&L,&R);
            if(op=='Q')
                printf("%d\n",query(1,1,n,L,R));
            else
                update(1,1,n,L,R);
        }
    }
    return 0;
}


HDU 1166 敌兵布阵

单点更新，查询区间和【此题树状数组解法转见→】

#include <cstdio>
#include <cmath>
#include <iostream>
using namespace std;
#define FOR( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define RE freopen("1.in","r",stdin);
#define bug(x) cout<<#x<<":"<<(x)<<endl;

#define Mid ((l+r)>>1)
#define lson rt<<1,l,Mid
#define rson rt<<1|1,Mid+1,r

const int maxn= 50000+5;
const int inf=0x3f3f3f3f;
int sum[maxn<<2];
int ans1,ans2;

void build(int rt,int l,int r)
{
    if(l==r){
        scanf("%d",&sum[rt]);
    }else{
        build(lson);
        build(rson);
        sum[rt] = sum[rt<<1] + sum[rt<<1|1];
    }
}
void update(int rt,int l,int r,int pos,int num)
{
    if(l == r && r == pos){     
        sum[rt] += num;
    }else{
        if( pos <= Mid)
            update(lson,pos,num);
        else        
            update(rson,pos,num);
        sum[rt] = sum[rt<<1] + sum[rt<<1|1];
    }
}

int query(int rt,int l,int r,int L,int R)
{
    if(L <= l && r <= R){
        return sum[rt];
    }else{
        int tmp = 0;
        if( L <= Mid)
            tmp += query(lson,L,R);
        if( R > Mid)
            tmp += query(rson,L,R);
        return tmp;
    }
}

int main()
{
//    RE
    int n,m,L,R,t;
    char op[10];
    scanf("%d",&t);
    for(int cas=1;cas<=t;cas++){
        scanf("%d",&n);
        build(1,1,n);
        printf("Case %d:\n",cas);
        while(scanf("%s",op),op[0]!='E'){
            scanf("%d%d",&L,&R);
            if(op[0]=='Q')
                printf("%d\n", query(1,1,n,L,R));
            else if(op[0]=='A')
                update(1,1,n,L,R);
            else
                update(1,1,n,L,-R);
        }
    }
    return 0;
}




Lazy


区间成段更新

Lazy：正常来说，区间改值，当更改某个区间的值的时候，子区间也该跟着更改，这样容易TLE。

Lazy思想就是更新到某个区间的时候，就先给这个区间打上标记，标记内容是需要更新的值，并把子区间的值改为子区间对应的值，清除该区间的lazy标记；然后return，不去更新子区间。当下一次更新或查询等需要访问该区间的子区间的时候再把该区间的lazy和其他信息送回子区间。


举个简单粗暴的例子：

对应下面的那个图，假如目的是求和，现在要给[1,6] 的值都加2，那么我们从[1,12]->[1,6]，然后[1,6]的sum值加上区间长度[ (6-1+1)*2 ]，再把[1,6]的add[i]设置为2，就不再往下更新了【这里极大提高效率】。下一次更新/查询[1,6]的子区间时，我们将[1,6]原存的add值下传给[1,6]的两个直接子区间，再往下更新。假设在这种情况下，我们再更新[1,6]加3，则[1,6]的add值为2+3=5，然后我们查询[1,3]，则从上往下经过[1,6]时把[1,6]的add值给了子区间[1,3]和[4,6]，同时把sum[子区间]跟着子区间长度和add[父结点]改动，清除add[父节点]。【如果是查询间接子区间，则连续传递add值，也就是连续pushDown】


详细例子：假设update()是区间改值，query()是求和，所有叶子区间的和都为1，则[7,8]和[7,9]在build()的时候就附上了值（图中绿色字体）。假设此时我们更新[7,9]的值，改为2，则线段树从[1,12]->[7,12]->[7,9]，然后把[7,9]打上值为2的标记，求和（求和直接用区间长度*此时更新的值），然后不去更新[7,8]和[9,9]了，他们值仍然是2和1，lazy值为0。


然后我们查询[7,8]，当遍历经过[7,9]时

 if(add[i])
        pushDown(i);

成立，把[7,9]的lazy标记2传给子区间[7,8]和[9,9],分别求这2个子区间的和，把[7,9]的lazy标记去掉，然后继续遍历，到[7,8]的时候直接返回答案。



HDU 1698 Just a Hook 区间改值，求和

#include <cstdio>
#include <cmath>
#include <iostream>
#include <algorithm>
using namespace std;
#define ll long long
#define FOR( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define RE freopen("1.in","r",stdin);
#define WE freopen("1.out","w",stdout);
#define MOD 10009
#define bug(x) cout<<#x<<":"<<(x)<<endl;

#define Mid ((l+r)>>1)
#define lson rt<<1,l,Mid
#define rson rt<<1|1,Mid+1,r
const int maxn = 100010;
int sum[maxn<<2],add[maxn<<2];

void build(int rt,int l,int r)
{
    add[rt] = 0;
    if(l == r){
        sum[rt] = 1;
    }else{
        build(lson);
        build(rson);
        sum[rt]=sum[rt<<1]+sum[rt<<1|1];
    }
}

void pushDown(int rt,int len)
{
    add[rt<<1] = add[rt<<1|1] = add[rt];
    sum[rt<<1] = (len-(len>>1))*add[rt];
    sum[rt<<1|1] = (len>>1)*add[rt];
    add[rt] = 0;
}

void update(int rt,int l,int r,int L,int R,int z)
{
    if(L <= l && r <= R){
        add[rt] = z;
        sum[rt] = (r-l+1)*z;
    }else{
        if(add[rt])
            pushDown(rt,r-l+1);
        if(L <= Mid)
            update(lson,L,R,z);
        if(R > Mid)
            update(rson,L,R,z);
        sum[rt] = sum[rt<<1] + sum[rt<<1|1];
    }
}

int main()
{
//    RE;
    int t,n,q,x,y,z;
    int cnt=1;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&q);
        build(1,1,n);
        while(q--){
            scanf("%d%d%d",&x,&y,&z);
            update(1,1,n,x,y,z);
        }
        printf("Case %d: The total value of the hook is %d.\n", cnt++,sum[1]);
    }
    return 0;
}

相关链接：线段树题目合集                  二维线段树                       线段树模板


角落的秋天
关注
  • 60
    点赞
  • 踩
  • 167
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
C# Lazy 延迟优化算法对比.cs
06-15
C# Lazy 延迟优化算法对比 C# Lazy 延迟优化算法对比
线段树（单点查询+区间求和）无lazy标记
01-20
原理就大概如图所示，线段树的每个节点都是原数组的一段区间和，而叶子节点就是原数组对应 的值 建树代码： void build(int p,int lf,int rt){//建树 ans[p]=0; if(lf==rt) { ans[p]=A[lf]; return ; } int mid...
线段树 (lazy标记)--- 模板
weixin_45705885的博客
09-18 482
线段树A：建树B：单点更新C：区间查询D：区间更新 (lazy标记) 每次并不断的分,不断的分，更新，查询 的操作都是 log(N)。 A：建树 const int maxx=100019; int a[maxx],tree[maxx*4]; void build(int node,int start,int endd) //build(0,1,10) 从0开始建树。start,endd 是实际的数组的下标范围 { if(start==endd) //到达叶子节点 { t
算法模板——线段树之Lazy标记
Wolfycz的博客
12-09 1499
一.前言 前面我们已经知道线段树能够进行单点修改和区间查询操作（基本线段树）。那么如果需要修改的是一个区间该怎么办呢？如果是暴力修改到叶子节点，复杂度即为O(n)O(n)，显然是十分不优秀的。那么我们能不能向区间查询一样把复杂度降到O(logn)O(log_n)呢？ 二.算法流程 线段树肯定是兹瓷O(logn)O(log_n)修改的，否则发明它有何用处？所以，我我们现在需要知道，如何快速进行
【例题】【线段树】lazy
ANG
07-11 744
1、 (1)、Lazy思想：对整个结点进行的操作，先在结点上做标记，而并非真正执行，直到根据查询操作的需要分到下层。 (2)、延迟标记 Lazy：如果需要对一个区间中每一个叶结点进行操作,我们不妨先别忙着操作，而是在所有大区间上做一个标记, 下一次遇到或要用到时，再进行处理(标记传递)，达到减少操作次数，提高线段树的效率的作用。2、 NKOJ 2297 数列操作2 时间限制 : 1000
线段树进阶之lazy思想及Java实现
weixin_45685353的博客
12-14 840
背景： 在上一篇线段树入门中涉及到对线段树的更新操作是单点操作，即更新的是一个，如果现在把问题升级下，让你将数组nums的某个区间[start,end]的值都加上value，该怎么做好呢？比较容易想到的是可以复用之前的更新操作，外面给它套个for循环，依次更新，这样虽然结果正确，但时间复杂度不堪入目…很明显是不可取的，基于这个问题，从而有了lazy思想，下面开始介绍。 概述： lazy，顾名思义，就是懒惰的意思，在本问题中所体现的则是在进行区间更新时，延迟更新，用一个lazy标记记录下就好，没必要依次更新它
线段树详解
good good study, day day up!
05-11 808
线段树
线段树(lazy用法)
malloch的博客
08-14 1977
在上一篇中，我们讨论了线段树的基础用法，其中我们对于线段树的修改，仅仅限制于对于线段树的点的修改，而不是对于某一个一段区间的修改。 那么我们现在来想想如果对于线段树的一段区间来进行修改的话，如果我们还是来对线段树的每一个点都进行修改的话，那么，假设我们需要修改m个点，其时间复杂度岂不是为O(log(n))了，那么我们所需要的少的时间复杂度的要求就没有达成，为此，lazy数组应运而生，来解决这个问题。 首先我们来认识一下lazy：如果当前区间被需要修改的目标区间完全覆盖，打一个标记。如果下一次的查询或者更改包
线段树的懒标记与应用
m0_52711790的博客
01-25 1511
本文主要讲了线段树的Lazy-tag技术和一道例题，建议自己要多练习线段树的题目。
线段树模版（比较基本的线段树以及例题模板）
最新发布
11-01
这篇内容主要包含了一些我写的线段树的代码，可以帮助大家更好的理解线段树建树，lazy_tag，和区间修改，区间最大值一系列的内容。 如果有需要的话可以下载看看。希望能帮助大家。 这几份代码仅供参考，不要抄袭，...
javascript preload&lazy load
10-29
最近需要用到预加载和延迟加载的东东，就参考写了一个。支持跨页面，支持超时设置与依赖设置。
jQuery_lazyload
01-07
jQuery_lazyload插件示例Demo
LazyLoad实例
02-02
LazyLoad页面加载技术实例，根据页面滚动加载图片 LazyLoad页面加载技术实例，根据页面滚动加载图片
最短路径详解
热门推荐
某科学的程序员
05-05 2万+
Floyd-Warshall 原理 实现 Dijkstra 简单粗暴的原理 过程 实现 Spfa 原理 证明 实现 Bellman-Ford 最短路径：一个图里有很多边，每条边有权值，两点之间的权值最小的路径。 负权回路：一个环（某点出发走了一圈还回到原点）里的权值和为负数（环里的每个权值可正可负，但和为负）。 首先，存在负权回路的图里没有最短路，因为只要一直走这个回...
二分答案法、三分法
某科学的程序员
03-15 1万+
二分大法好
第K大/Top K及其简单实现
某科学的程序员
08-14 6070
转载请注明出处：http://blog.csdn.net/u012469987/。 见网上第K大多数只给思路，没给实现，我就来填坑了。 update 2017-09-23 有同学反馈说面试遇到这个题，博文给了助攻，哈预料之中。 Top K 和第K大基本等价，以下我们以第K大为例且假设第K大一定存在，Top K 可以在第k大基础上稍微改动获得。 本文介绍6种方法，只考虑实现功能，不做异...
扩展GCD
某科学的程序员
09-04 4516
扩展GCD(欧几里得)：求方程ax+by=gcd(a,b)中的x,y
线段树lazy_tag
10-14
线段树的 lazy tag 是一种优化技巧，用于解决区间修改的问题。具体来说，当我们需要对一个区间进行修改时，我们不直接修改区间内的所有元素，而是将修改操作打上一个标记，然后在查询时再根据标记进行相应的处理。 举个例子，假设我们需要对区间 [l, r] 内的所有元素加上一个值 val。如果我们直接暴力修改，时间复杂度为 O(r-l+1)，而使用 lazy tag 的时间复杂度为 O(logn)。具体实现时，我们可以在每个节点上维护一个 lazy_tag 变量，表示该节点所代表的区间需要加上的值。当我们需要对该区间进行查询时，我们先将该节点的 lazy_tag 加到查询结果中，然后再将 lazy_tag 下传给左右儿子节点。当我们需要对该区间进行修改时，我们只需要将该节点的 lazy_tag 加上修改值即可，然后将 lazy_tag 下传给左右儿子节点。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值