线段树（区间问题）

最新推荐文章于 2024-03-04 23:41:32 发布
最新推荐文章于 2024-03-04 23:41:32 发布
阅读量395 收藏 1
点赞数
分类专栏： 数据结构 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40679299/article/details/81638657
版权

目录

单点操作

Lazy标记

       1.集中更新和动态统计子序列中的数据。

       2.计算可见线段

       3.互不相交线段的更新与维护。

单点操作

#include <iostream>
using namespace std;

const int MAX_N=10010;
int s[4*MAX_N];

void up(int p){
    s[p]=s[p*2]+s[p*2+1];
}

void modify(int p,int l,int r,int x,int v){
    //节点x上的权值增加v;
	if(l==r){
		s[p]+=v;
        return ;
    }
    int mid=(l+r)/2;
    if(x<=mid){
        modify(p*2,l,mid,x,v);
    }else{
        modify(p*2+1,mid+1,r,x,v);
    }
    up(p);
}

int query(int p,int l,int r,int x,int y){
    //p,l,r为当前更新到的节点，左右端点，x,y为要查询的区间
    if(x<=l&&r<=y){
        return s[p];
    }
    int mid=(l+r)/2,res=0;
    if(x<=mid){
        res+=query(p*2,l,mid,x,y);
    }
    if(y>mid){
        res+=query(p*2+1,mid+1,r,x,y);
    }
    return res;
}

int main() {
	int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        int d;
        cin>>d;
        modify(1,1,n,i,d);
    }
    int q;
    cin>>q;
    while(q--){
        int d,x,y;
        cin>>d>>x>>y;
        if(d==0){       //x处增加y
            modify(1,1,n,x,y);
        }else{//询问x-y的和
            cout<<query(1,1,n,x,y)<<endl;
        }
    }
    return 0;
}

Lazy标记

1.集中更新和动态统计子序列中的数据。

（1）子序列增加或者减少一个值

（2）子序列求和

例：POJ3468 

#include<cstdio>
#include<cstring>

using namespace std;

const int maxn=1e5+10;

typedef long long ll;

struct node{
    ll mark,sum;        //线段树，其中节点i的数和为sum，懒惰标记为mark
}tree[maxn*4];

int x[maxn];            //初始值序列。
int n,m;                //数字个数，操作次数。

void update(int l,int r,int i){                     //标记法维护线段树（根为i，对应区间为[l,r]）
    if(!tree[i].mark) return;                       //若结点i未被标记，则退出，否则左右儿子对应的区间应该被完全覆盖，分别计算左右子区间的数和，并将节点i的标记下传给左右儿子。
    int mid=l+r>>1;
    tree[i<<1].sum+=tree[i].mark*(ll)(mid-l+1);
    tree[i<<1|1].sum+=tree[i].mark*(ll)(r-mid);
    tree[i<<1].mark+=tree[i].mark;
    tree[i<<1|1].mark+=tree[i].mark;
    tree[i].mark=0;                                 //撤去标记 
}

ll query(int tl,int tr,int l,int r,int i){          //计算线段树根为i，对应区间为[l,r]内子区间[tl,tr]的数字和。
    if(tl>r||tr<l) return 0;
    if(tl<=l&&r<=tr) return tree[i].sum;            //标记法维护
    update(l,r,i);
    int mid=l+r>>1;
    return query(tl,tr,l,mid,i<<1)+query(tl,tr,mid+1,r,i<<1|1);
}

void add_value(int tl,int tr,int l,int r,int i,int val){    //线段树根为i，对应区间为[l,r]内子区间[tl,tr]每个数+val
    if(tl>r||tr<l) return ;
    if(tl<=l&&r<=tr){
        tree[i].sum+=val*(ll)(r-l+1);
        tree[i].mark+=val;
        return;
    }
    update(l,r,i);
    int mid=(l+r)>>1;
    add_value(tl,tr,l,mid,i<<1,val);
    add_value(tl,tr,mid+1,r,i<<1|1,val);
    tree[i].sum=tree[i<<1].sum+tree[i<<1|1].sum;
}

void build_tree(int l,int r,int i){                          //构建以i为根，对应区间[1,n]的线段树。
    if(l==r){
        tree[i].sum=x[l];
        return;
    }
    int mid=l+r>>1;
    build_tree(l,mid,i<<1);
    build_tree(mid+1,r,i<<1|1);
    tree[i].sum=tree[i<<1].sum+tree[i<<1|1].sum;
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d",&x[i]);
    }
    memset(tree,0,sizeof tree);
    build_tree(1,n,1);
    while(m--){
        char ch;
        int l,r,v;
        scanf(" %c",&ch);
        if(ch=='Q'){                                    //询问[l,r]的区间和。
            scanf("%d%d",&l,&r);
            ll ans=query(l,r,1,n,1);
            printf("%lld\n",ans);
        }else{                                          //[l,r]中每个数均加上v
            scanf("%d%d%d",&l,&r,&v);
            add_value(l,r,1,n,1,v);
        }
    }
    return 0;
}

2.计算可见线段

被插入的线段按照先后顺序，后面覆盖前面的，计算最终线段并区间中的可见线段数。

注意可能用到离散化。

例POJ 2528

#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

const int maxn=1e4+10;

//线段i表示颜色i
bool tab[maxn];             //颜色码k被使用的标志是tab[k]
int l[maxn],r[maxn],x[maxn*3],num[maxn*3],tree[maxn*12];
/*
对于第i张海报来说，不大于左边界的不同坐标数为l[i]，不大于右边界的不同坐标数为r[i]，左边界坐标为x[3*i-2]，右边界坐标为x[3*i-1]；
中间位置坐标为x[3*i]，x[]排序后x[1...j]中不重复的坐标数为num[j]；
线段树中的节点k标记为tree[k]，即代表区间的颜色码。
*/

void update(int i){          //标记法维护线段树。
    if(!tree[i]) return ;
    tree[i<<1]=tree[i<<1|1]=tree[i];
    tree[i]=0;
}

void change(int tl,int tr,int l,int r,int i,int co){
    if(tr<l||tl>r) return;
    if(tl<=l&&r<=tr){
        tree[i]=co;
        return ;
    }
    update(i);
    int mid=l+r>>1;
    change(tl,tr,l,mid,i<<1,co);
    change(tl,tr,mid+1,r,i<<1|1,co);
}

int query(int l,int r,int i){
    if(tree[i]){
        if(!tab[tree[i]]){
            tab[tree[i]]=1;
            return 1;
        }
        return 0;
    }
    if(l==r) return 0;      //当前点未覆盖，则返回0
    int mid=l+r>>1;
    return query(l,mid,i<<1)+query(mid+1,r,i<<1|1);
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--){
        int n,cnt=0;
        scanf("%d",&n);
        for(int i=1;i<=n;i++){
            scanf("%d%d",&l[i],&r[i]);
            x[++cnt]=l[i],x[++cnt]=r[i],x[++cnt]=(l[i]+r[i])/2;
            //因为是区间，所以直接离散化的话可能导致可看见的区间数减少。所以添加一个中间值进行离散化。
        }
        sort(x+1,x+1+cnt);
        cnt=unique(x+1,x+cnt+1)-(x+1);
        memset(tree,0,sizeof tree);
        for(int i=1;i<=n;i++){
            int ll=lower_bound(x+1,x+1+cnt,l[i])-x;
            int rr=lower_bound(x+1,x+1+cnt,r[i])-x;
            change(ll,rr,1,cnt,1,i);
        }
        memset(tab,0,sizeof tab);
        int ans=query(1,3*n,1);
        printf("%d\n",ans);
    }
    return 0;
}

3.互不相交线段的更新与维护。

每次给出插入线段的长度l，若线段树中存在空位置数不小于l的子区间，则该线段插入（一般规定选择区间的优先级），可使树中满的线段是互不相交的，对删除操作，若线段树中存在被删线段的“满区间”，则该线段可被删除。

节点的懒惰标记一般包括:

（1）对应子区间的占据情况mark：分“全满”，“全空”，“部分占据”三部分。

（2）对应子序列的最长空区间lm，pos，即pos位置开始，长度为lm的区间为最长空区间。

（3）左端 最长空区间的长度ls，和右端最长空区间的长度rs，即跨越左右子区间的最长空区间的长度为ls+rs；

例如：POJ 3667

#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

const int maxn=5e4+10;

struct node{
    int ls,rs,ms,pos,mark;
}tree[maxn*4];

/*线段树,其中节点i的懒惰标记:对应区间为tree[i].mark(0为未定,1为全空,2为全满)
 *左端空区间的长度为tree[i].ls,右端区间的长度为tree[i].rs,最长子区间的长度为
 *tree[i].ms,开始区间为tree[i].pos.
 */

int n,m;        //房间数,请求数.

void build_tree(int l,int r,int i){
    tree[i].ls=tree[i].rs=tree[i].ms=r-l+1;
    tree[i].pos=l;
    if(l==r) return;
    int mid=l+r>>1;
    build_tree(l,mid,i<<1);
    build_tree(mid+1,r,i<<1|1);
}

bool all_space(int l,int r,int i){      //若结点i对应的区间[l,r]全空则返回1,否则返回0;
    if(tree[i].ls==r-l+1) return 1;
    return 0;
}

void update(int l,int r,int i){
    if(!tree[i].mark) return;   //若结点i的区间未定,则返回.
    if(tree[i].mark==1){        //节点i全空,则r-l+1个空位置均分给左右子树,左右子数设全空状态.
        int len=r-l+1;
        tree[i<<1].ls=tree[i<<1].rs=tree[i<<1].ms=len+1>>1;
        tree[i<<1].pos=l;
        tree[i<<1|1].ls=tree[i<<1|1].rs=tree[i<<1|1].ms=len>>1;
        tree[i<<1|1].pos=(l+r>>1)+1;
        tree[i<<1].mark=tree[i<<1|1].mark=1;
    }else{                       //全满,0个空位置传给左右子树,左右子数设为全满状态.
        tree[i<<1].ls=tree[i<<1].rs=tree[i<<1].ms=0;
        tree[i<<1].pos=l;
        tree[i<<1|1].ls=tree[i<<1|1].rs=tree[i<<1|1].ms=0;
        tree[i<<1|1].pos=(l+r>>1)+1;
        tree[i<<1].mark=tree[i<<1|1].mark=2;
    }
    tree[i].mark=0;             //设节点i的状态待定.
}

int query(int d,int l,int r,int i){     //若线段树(根为i,对应区间为[l,r])存在长度为d的空区间,则返回其左指针,否则返回0.
    update(l,r,i);                      //通过标记法维护线段树.
    if(tree[i].ms<d) return 0;
    if(tree[i].ms==d) return tree[i].pos;
    int mid=l+r>>1;
    if(tree[i<<1].ms>=d)                 //若左子树的空位不小于d,则递归左子树.
        return query(d,l,mid,i<<1);
    if(tree[i<<1].rs+tree[i<<1|1].ls>=d)    //若跨越中间点的空子区间的不小于d,则返回空子区间的左指针,否则递归右子树.
        return mid-tree[i<<1].rs+1;
    return query(d,mid+1,r,i<<1|1);
}

void change(int tl,int tr,int l,int r,int i,bool flag){
    //线段树(根为i,对应区间为[l,r])中插入或删除线段[tl,tr],插删标志为flag
    if(tl>r||tr<l) return;
    if(tl<=l&&r<=tr){       //线段[tl,tr]完全覆盖区间[l,r].
        if(flag){           //若为插入操作,则节点i代表的区间全满.
            tree[i].ls=tree[i].rs=tree[i].ms=0;
            tree[i].pos=l;
            tree[i].mark=2;
        }else{
            tree[i].ls=tree[i].rs=tree[i].ms=r-l+1;
            tree[i].pos=l;
            tree[i].mark=1;
        }
        return;
    }
    update(l,r,i);
    int mid=l+r>>1;
    change(tl,tr,l,mid,i<<1,flag);
    change(tl,tr,mid+1,r,i<<1|1,flag);
    //回溯往上进行修改.
    tree[i].ls=tree[i<<1].ls;
    if(all_space(l,mid,i<<1))              //如果左子树全为空
        tree[i].ls+=tree[i<<1|1].ls;
    tree[i].rs=tree[i<<1|1].rs;
    if(all_space(mid+1,r,i<<1|1))           //如果右子树全为空
        tree[i].rs+=tree[i<<1].rs;
    //节点i所代表的区间的最长空区间的长度.
    tree[i].ms=max(tree[i<<1].rs+tree[i<<1|1].ls,max(tree[i<<1].ms,tree[i<<1|1].ms));
    if(tree[i].ms==tree[i<<1].ms)           //最长空子区间在左子树.
        tree[i].pos=tree[i<<1].pos;
    else if(tree[i].ms==tree[i<<1].rs+tree[i<<1|1].ls)
        tree[i].pos=mid-tree[i<<1].rs+1;
    else tree[i].pos=tree[i<<1|1].pos;
}

int main()
{
    scanf("%d%d",&n,&m);
    memset(tree,0,sizeof tree);
    build_tree(1,n,1);
    while(m--){
        int kind;
        scanf("%d",&kind);
        if(kind==1){                //入住请求
            int d;
            scanf("%d",&d);         //输入入住的房间数
            int ans=query(d,1,n,1); //检查线段树(根为i,对应区间为[l,r])是否存在长度为d的空区间,存在返回其左指针,否则返回0.
            printf("%d\n",ans);
            if(ans){
                change(ans,ans+d-1,1,n,1,1);
            }
        }else{
            int x,d;
            scanf("%d%d",&x,&d);    //x开始的d间房间退房.
            change(x,x+d-1,1,n,1,0);
        }
    }
    return 0;
}

 

兜率工
关注
专栏目录
[CODEVS3243]区间翻转（线段树||splay||块链）
zyf2000
09-18 1011
All that you have lost can be won back bit by bit as long as you wish for it.
Count the Colors （线段树区间染色问题）
ldu_商正昌的博客
08-07 762
Painting some colored segments on a line, some previously painted segments may be covered by some the subsequent ones. Your task is counting the segments of different colors you can see at last. Input...
数据结构——线段树
最新发布
wangyuanbo_的博客
03-04 904
例111 题目描述 给定一个长为nnn的序列，有mmm次操作，每次操作为以下三种之一。 修改序列中的一个数 求序列中某连续一段所有数的两两乘积的和mod1000000007\text{mod} 1000000007mod1000000007。 求序列中某连续一段所有相邻两数乘积的和mod1000000007\text{mod} 1000000007mod1000000007。 做法 一般单点修改的难点都在于区间合并信息的操作。 Part1\text{Part}1Part1 先考虑第二个操作，假设对于一个
线段树解决区间计算问题
weixin_45724872的博客
04-21 210
问题一、 POJ3264 这一题只涉及了查询线段树的最大值&最小值 Code #include <iostream> #include <utility> #define lc (p<<1) #define rc (p<<1|1) using namespace std; const int N = 5e4+10; struct Node{ int l,r; int maxn; int minn; }tree[N<&l
线段树求区间和
爱笑的k11的博客
01-17 132
代码 public class LineTreeDemo { //求区间和 private int L; private int R; private int rt; private Node buildLineTree(int[] arr,int rt,Node[] dest,int L,int R){ if(L == R){ ...
线段树（求区间极值）
Hello Will
04-18 306
public class SegTree { private static int[] base = {5, 9, 7, 4, 6, 1}; private static segNode[] nodes = new segNode[(base.length << 1) + 2];//n个叶节点，n-1个度为2的节点 public static void mai...
线段树求解区间值问题
oliver233的博客
04-12 490
线段树： 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN）。而未优化的空间复杂度为2N，因此有时需要离散化让空间压缩。 上一篇博客求解RMQ问题，查询区间最值，活某种特定的值，是利用动态规划的思想，先预处理，将各个区间的最值存进数组中，再利用O(
线段树区间更新code
12-22
线段树区间更新代码线段树区间更新代码线段树区间更新代码线段树区间更新代码
线段树区间修改
Mr.Amazing的博客
05-08 1163
区间修改区间查询里面用到了一个lazytag方法 具体的意思就是：要修改某区间（L,R）的值时，不修改到底，而是修改到L<=begin&&R>=end时，直接对begin到end区间的和进行修改，修改后在次节点做一个标记add[node]=x（x为修改值），如果add[node]不为零，说明我并没有将此节点的更改向下延伸到叶子节点。至于什么时候向下更新到叶子结点，则是到下一次更新到此节点或者是区间查询查询到此节点时进行更新。 #include <iostream&..
线段树（单点查询+区间求和）无lazy标记
01-20
线段树是一种高效的数据结构，常用于处理动态区间查询和修改问题。在“线段树（单点查询+区间求和）无lazy标记”这个题目中，主要涉及到线段树的基本操作，包括如何构建线段树、单点修改以及区间求和。 1. **线段树...
ZKW线段树区间加区间取最值
Freopen的博客
08-09 1129
本来以为是和zkw单点修改之类的简单技巧，但是今天卡常的时候学习了一下发现有点离谱。 树状数组的区间加区间求和是利用差分和一次前缀和来完成的，但是写在线段树上就不用差分了。 但是可以差分，并且zkw线段树提供了一种线段树式的差分方法： 对于每个点，只存一个标记trxtr_xtrx​，表示max⁡fax−max⁡x\max_{fa_x} - \max_{x}maxfax​​−maxx​，也就是线段树上一个节点和他父亲区间最大值的差分，我们现在可以知道一个线段树上一个整区间的最大值就是他到根的和。 那么我们求区
codevs3243：区间翻转，线段树
cww97的博客
01-07 962
题目描述 Description 给出N个数，要求做M次区间翻转（如1 2 3 4变成4 3 2 1），求出最后的序列输入描述 Input Description 第一行一个数N，下一行N个数表示原始序列，在下一行一个数M表示M次翻转，之后的M行每行两个数L，R表示将区间[L,R]翻转。输出描述 Output Description 一行N个数 ， 表示最终序列。样例输入 Sample Inp
[SPOJ IITWPC4F Gopu and the Grid Problem]线段树区间翻转
Fighting!
01-04 835
[SPOJ IITWPC4F Gopu and the Grid Problem]线段树区间翻转知识点：data structure segment tree1. 题目链接[SPOJ IITWPC4F Gopu and the Grid Problem]2. 题意描述在一个二维X−YX-Y平面(0≤x,y≤100000)(0\le x,y\le 100000)上有三种操作。操作次数为qq。(q≤10
Codeforces 1401 F. Reverse and Swap —— 线段树，区间翻转
天翼之城的博客
09-12 231
This way 题意： 给你一个长度为2n2^n2n的数组，有4种操作： 嗝太长了，自己看一下吧 题解： 我一开始还想着用FHQ Treap，没仔细考虑时间复杂度，如果2,3操作每次k都是0的话，就是n2logn^2logn2log的时间复杂度。 然后的话，由于是简单翻转没有插入删除，于是可以用线段树，区间打上翻转标记就行了，第二种和第三种有一些区别。 操作二的话，就需要在深度为k以及之后的所有深度都打上左右互换标记，这样的话，就能表示区间翻转了 操作三的话，需要在深度是k+1的位置打上左右互换标记就
序列操作（线段树）
DZYO的博客
07-04 553
Description Lxhgww 最近收到了一个 01 序列，序列里面包含了 n（1≤n≤105）个数，这些书要么是 0，要么是 1，现在对这个序列有五种变换操作和询问操作：0 a b ，把[a，b]区间内所有数全部变成 0。 1 a b ，把[a，b]区间内所有数全部变成 1。 2 a b ，把[a，b]区间内所有数全部取反，也就是说把所有的 0 变成 1，把所有的 1 变成 0。
2023-07-26力扣每日一题-区间翻转线段树
Fei_WuYan的博客
07-26 314
，而且每次查询都查询整个nums2，所以只要维护一个nums2的和sum，不用考虑修改nums2。（下面都是类内函数）构建函数设计，使用递归求和，这边注意运算符优先级。区间，那么直接整个区间打上懒标记；，p由操作给出，any表示数组里的每一位。由于每次更新nums2的时候，不需要考虑。区间修改函数，如果当前修改段包含。操作3：查询nums2的和。增减，但增减多少不取决于。操作1：将nums1的。翻转（0变1,1变0）
POJ2823 - 线段树求区间的最值..
zzyzzy12
08-22 1774
本来想搞单调队列的....结果网上搜单调队你列的题...一搜搜到这道...一看...果断敲线段树..还没写过线段树求最值的....在求和上稍微修改下就可以了...而且这个题目没有修改的...所以一开始建好树后...不需要Updata...只要寻找答案就可以了...这个程序的主心部
根节点区间长度为N的线段树层数的上下限
Hoxily的窝窝
03-13 747
根节点区间长度为N的线段树，其层数的上下限层数上限 记命题P(n)表示根节点区间长度从1,2,3到2^n的线段树，这些线段树的层数小于等于n+1。 1. 易知根节点区间长度为1的线段树层数为1；根节点区间长度为2的线段树层数为2；即当n=1时，P(n)成立。 2. 假设当n=k(k>=1)时，P(n)成立，证明P(n+1)成立。 3. 综合1、2两步，可知对任意自然数n>=1,命题P(n)成立
[bzoj5259][线段树]区间
Rose_max的博客
03-26 578
Description 给定一个1到n的排列a1, . . . , an。 对于一个区间[l, r]，我们称该区间是连续的，如果将al, . . . , ar排列之后得到的是一列连续的数。 （换句话说，如果x,y都在该区间中，那么所有介于x,y之间的数也在该区间中） 现在有m(1 ≤ n, m ≤ 100000)个询问，每个询问给出一个区间[xi, yi], 你需要找到一个长度最短的连续区间[l...
优化查询：蛇形线段树解决区间操作问题
蛇形线段树是一种特殊的数据结构，常用于处理区间查询问题，尤其在需要对大量数据进行高效更新和查询的场景中。在题目中提到的应用中，例如在动态数组中执行一系列操作，包括区间加值、置值和查询区间统计信息，常规...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值