线段树模板合集--单点替换，区间替换，区间增加3种情况

最新推荐文章于 2023-12-20 23:28:23 发布
最新推荐文章于 2023-12-20 23:28:23 发布
阅读量4.7k 收藏 12
点赞数 1
分类专栏： 数据结构 文章标签： 线段树 数据结构 模板 acm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq547276542/article/details/51536564
版权

1.单点覆盖，区间查询

#include <cstdio>
#include <algorithm>
#include <iostream>
using namespace std;
#define lson l , m , rt << 1
#define rson m + 1 , r , rt << 1 | 1
const int maxn = 100007;
const int INF=0x7fffffff;
int MAX[maxn<<2];
int MIN[maxn<<2];
int SUM[maxn<<2];
void PushUP(int rt) {
    MAX[rt] = max(MAX[rt<<1] , MAX[rt<<1|1]);
    MIN[rt] = min(MIN[rt<<1] , MIN[rt<<1|1]);
    SUM[rt] = SUM[rt<<1] + SUM[rt<<1|1];
}
//所有的 l ,r ,rt 参数为 1，n,1   其中n为区间长度
void build(int l,int r,int rt) {   //建树
    if (l == r) {
        MAX[rt] = MIN[rt] =SUM[rt]=0;  //初始化线段树为0的写法
        /*
          //边读入边建树的写法，复杂度O(n)  若执行n次更新来初始化的话复杂度为O（nlogn）
            scanf("%d",&MAX[rt]);
            MIN[rt] = MAX[rt];
            SUM[rt] = MAX[rt];
        */
        return ;
    }
    int m = (l + r) >> 1;
    build(lson);
    build(rson);
    PushUP(rt);
}
void update(int p,int v,int l,int r,int rt) {  //单点替换，把p位置的值置为v
    if (l == r) {
        MAX[rt] = v;
        MIN[rt] = v;
        SUM[rt] = v;
        return ;
    }
    int m = (l + r) >> 1;
    if (p <= m) update(p , v ,lson);
    else update(p , v , rson);
    PushUP(rt);
}
void update1(int p,int addv,int l,int r,int rt) {  //单点增加，把p位置的值增加v
    if (l == r) {
        SUM[rt] = SUM[rt] + addv;
        MIN[rt] = MIN[rt] + addv;
        MAX[rt] =MAX[rt]+addv;
        return ;
    }
    int m = (l + r) >> 1;
    if (p <= m) update1(p , addv ,lson);
    else update1(p , addv , rson);
    PushUP(rt);
}
int queryMAX(int L,int R,int l,int r,int rt) {   //求L~R的最大值
    if (L <= l && r <= R) {
        return MAX[rt];
    }
    int m = (l + r) >> 1;
    int ret = -INF;
    if (L <= m) ret = max(ret , queryMAX(L , R , lson));
    if (R > m)  ret =  max(ret , queryMAX(L , R , rson));
    return ret;
}
int queryMIN(int L,int R,int l,int r,int rt) {  //求L~R的最小值
    if (L <= l && r <= R) {
        return MIN[rt];
    }
    int m = (l + r) >> 1;
    int ret = INF;
    if (L <= m) ret = min(ret , queryMIN(L , R , lson));
    if (R > m)  ret =  min(ret , queryMIN(L , R , rson));
    return ret;
}
int querySUM(int L,int R,int l,int r,int rt) {   //求L~R的和
    if (L <= l && r <= R) {
        return SUM[rt];
    }
    int m = (l + r) >> 1;
    int ret = 0;
    if (L <= m) ret += querySUM(L , R , lson);
    if (R > m)  ret +=  querySUM(L , R , rson);
    return ret;
}
int main() {
    int n , m;
    while (~scanf("%d%d",&n,&m)) {
        build(1 , n , 1);
        while (m --) {
            char op[2];
            int a , b;
            scanf("%s%d%d",op,&a,&b);
            if (op[0] == 'Q') { //区间求最大
                printf("%d\n",queryMAX(a , b , 1 , n , 1));
            } else if(op[0]=='U') //单点替换
                update(a , b , 1 , n , 1);
            else if(op[0]=='M') { //区间求最小
                printf("%d\n",queryMIN(a , b , 1 , n , 1));
            } else if(op[0]=='H') { //区间求和
                printf("%d\n",querySUM(a , b , 1 , n , 1));
            } else if(op[0]=='S') { //单点增加
                update1(a , b , 1 , n , 1);
            } else if(op[0]=='E') { //单点减少
                update1(a , -b , 1 , n , 1);
            }
        }
    }
    return 0;
}


2.区间覆盖，区间查询

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>

#define max(a,b) (a>b)?a:b
#define min(a,b) (a>b)?b:a
#define lson l , m , rt << 1
#define rson m + 1 , r , rt << 1 | 1
const int maxn = 100100;
const int INF=0x7fffffff;
using namespace std;
int lazy[maxn<<2];
int MAX[maxn<<2];
int MIN[maxn<<2];
int SUM[maxn<<2];
void PushUp(int rt) { //由左孩子、右孩子向上更新父节点
    SUM[rt] = SUM[rt<<1] + SUM[rt<<1|1];
    MAX[rt] = max(MAX[rt<<1],MAX[rt<<1|1]);
    MIN[rt] = min(MIN[rt<<1],MIN[rt<<1|1]);
}
void PushDown(int rt,int m) { //向下更新
    if (lazy[rt]) { //懒惰标记
        lazy[rt<<1] = lazy[rt<<1|1] = lazy[rt];
        SUM[rt<<1] = (m - (m >> 1)) * lazy[rt];
        SUM[rt<<1|1] = ((m >> 1)) * lazy[rt];
        MAX[rt<<1]=MAX[rt<<1|1]=lazy[rt];
        MIN[rt<<1]=MIN[rt<<1|1]=lazy[rt];
        lazy[rt] = 0;
    }
}
//所有的l，r，rt  带入1，n，1
void build(int l,int r,int rt) { //初始化建树
    lazy[rt] = 0;
    if (l== r) {
        SUM[rt]=MAX[rt]=MIN[rt]=0;  //初始化为0的建树
        /*scanf("%d",&SUM[rt]);  //边读入边建树的方法
          MAX[rt]=MIN[rt]=SUM[rt];
        */
        return ;
    }
    int m = (l + r) >> 1;
    build(lson);
    build(rson);
    PushUp(rt);
}
void update(int L,int R,int v,int l,int r,int rt) { //将L~R区间的值置为v
    //if(L>l||R>r) return;
    if (L <= l && r <= R) {
        lazy[rt] = v;
        SUM[rt] = v * (r - l + 1);
        MIN[rt] = v;
        MAX[rt] = v;
        //printf("%d %d %d %d %d\n", rt, sum[rt], c, l, r);
        return ;
    }
    PushDown(rt , r - l + 1);
    int m = (l + r) >> 1;
    if (L <= m) update(L , R , v , lson);
    if (R > m) update(L , R , v , rson);
    PushUp(rt);
}

int querySUM(int L,int R,int l,int r,int rt) {  //求区间L~R的和
    if (L <= l && r <= R) {
        //printf("%d\n", sum[rt]);
        return SUM[rt];
    }
    PushDown(rt , r - l + 1);
    int m = (l + r) >> 1;
    int ret = 0;
    if (L <= m) ret += querySUM(L , R , lson);
    if (m < R) ret += querySUM(L , R , rson);
    return ret;
}
int queryMIN(int L,int R,int l,int r,int rt) {  //求区间L~R的最小值
    if (L <= l && r <= R) {
        //printf("%d\n", sum[rt]);
        return MIN[rt];
    }
    PushDown(rt , r - l + 1);
    int m = (l + r) >> 1;
    int ret = INF;
    if (L <= m) ret = min(ret, queryMIN(L , R , lson));
    if (m < R) ret = min(ret,queryMIN(L , R , rson));
    return ret;
}
int queryMAX(int L,int R,int l,int r,int rt) {  //求区间L~R的最大值
    if (L <= l && r <= R) {
        //printf("%d\n", sum[rt]);
        return MAX[rt];
    }
    PushDown(rt , r - l + 1);
    int m = (l + r) >> 1;
    int ret = -INF;
    if (L <= m) ret = max(ret, queryMAX(L , R , lson));
    if (m < R) ret = max(ret,queryMAX(L , R , rson));
    return ret;
}

int main() {
    int  n , m;
    char str[5];
    while(scanf("%d%d",&n,&m)) {
        build(1 , n , 1);
        while (m--) {
            scanf("%s",str);
            int a , b , c;
            if(str[0]=='T') {
                scanf("%d%d%d",&a,&b,&c);
                update(a , b , c , 1 , n , 1);
            } else if(str[0]=='Q') {
                scanf("%d%d",&a,&b);
                cout<<querySUM(a,b,1,n,1)<<endl;
            } else if(str[0]=='A') {
                scanf("%d%d",&a,&b);
                cout<<queryMAX(a,b,1,n,1)<<endl;
            } else if(str[0]=='I') {
                scanf("%d%d",&a,&b);
                cout<<queryMIN(a,b,1,n,1)<<endl;
            }
        }
    }
    return 0;
}


3.区间增加，区间查询


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#define max(a,b) (a>b)?a:b
#define min(a,b) (a>b)?b:a
#define lson l , m , rt << 1
#define rson m + 1 , r , rt << 1 | 1
const int maxn = 100100;
const int INF=0x7fffffff;
using namespace std;
int lazy[maxn<<2];
int SUM[maxn<<2],MAX[maxn<<2],MIN[maxn<<2];
void putup(int rt) {
    SUM[rt] = SUM[rt<<1] + SUM[rt<<1|1];
    MAX[rt] =max(MAX[rt<<1],MAX[rt<<1|1]) ;
    MIN[rt] =min(MIN[rt<<1],MIN[rt<<1|1]);
}
void putdown(int rt,int m) {
    if (lazy[rt]) {
        lazy[rt<<1] += lazy[rt];
        lazy[rt<<1|1] += lazy[rt];
        SUM[rt<<1] += lazy[rt] * (m - (m >> 1));
        SUM[rt<<1|1] += lazy[rt] * (m >> 1);
        MAX[rt<<1]+=lazy[rt];
        MAX[rt<<1|1] +=lazy[rt];
        MIN[rt<<1]+=lazy[rt];
        MIN[rt<<1|1]+=lazy[rt];
        lazy[rt] = 0;
    }
}
//以下的 l,r,rt 都带入 1,n,1
void build(int l,int r,int rt) {  //初始化建树
    lazy[rt] = 0;
    if (l == r) {
        //初始化树为0的写法
        SUM[rt]=MAX[rt]=MIN[rt]=0;
        /*  //边读入边建树的写法
        scanf("%d",&SUM[rt]);
        MAX[rt]=MIN[rt]=SUM[rt];
        */
        return ;
    }
    int m = (l + r) >> 1;
    build(lson);
    build(rson);
    putup(rt);
}
void update(int L,int R,int v,int l,int r,int rt) {  //将区间L~R的值增加v
    if (L <= l && r <= R) {
        lazy[rt] += v;
        SUM[rt] += v * (r - l + 1);
        MAX[rt]+=v;
        MIN[rt]+=v;
        return ;
    }
    putdown(rt , r - l + 1);
    int m = (l + r) >> 1;
    if (L <= m) update(L , R , v , lson);
    if (m < R) update(L , R , v , rson);
    putup(rt);
}
int querySUM(int L,int R,int l,int r,int rt) {  //求区间L~R的和
    if (L <= l && r <= R) {
        return SUM[rt];
    }
    putdown(rt , r - l + 1);
    int m = (l + r) >> 1;
    int ret = 0;
    if (L <= m) ret += querySUM(L , R , lson);
    if (m < R) ret += querySUM(L , R , rson);
    return ret;
}
int queryMAX(int L,int R,int l,int r,int rt) {  //求区间L~R的最大值
    if (L <= l && r <= R) {
        return MAX[rt];
    }
    putdown(rt , r - l + 1);
    int m = (l + r) >> 1;
    int ret = -INF;
    if (L <= m) ret =max(ret,queryMAX(L , R , lson)) ;
    if (m < R) ret =max(ret,queryMAX(L , R , rson)) ;
    return ret;
}
int queryMIN(int L,int R,int l,int r,int rt) {  //求区间L~R的最小值
    if (L <= l && r <= R) {
        return MIN[rt];
    }
    putdown(rt , r - l + 1);
    int m = (l + r) >> 1;
    int ret = INF;
    if (L <= m) ret = min(ret,queryMIN(L , R , lson));
    if (m < R) ret = min(ret,queryMIN(L , R , rson));
    return ret;
}
int main() {
    int n , m;
    int a , b , c;
    char str[5];
    scanf("%d%d",&n,&m);
    build(1 , n , 1);
    while (m--) {
        scanf("%s",str);
        if (str[0] == 'S') {
            scanf("%d%d",&a,&b);
            printf("%d\n",querySUM(a , b , 1 , n , 1));
        } else if(str[0]=='C') {
            scanf("%d%d%d",&a,&b,&c);
            update(a , b , c , 1 , n , 1);
        } else if(str[0]=='A') {
            scanf("%d%d",&a,&b);
            printf("%d\n",queryMAX(a , b , 1 , n , 1));
        } else if(str[0]=='I') {
            scanf("%d%d",&a,&b);
            printf("%d\n",queryMIN(a , b , 1 , n , 1));
        }
    }
    return 0;
}


DASEason
关注
  • 1
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
线段树
遇见生活
12-10 427
1.线段树的每个节点都代表一个区间 2.线段树具有唯一的根节点，代表的区间是整个统计范围 3.线段树的每个叶子节点都代表一个长度为1的元区间 4.对于每个内部节点【l,r】，他的左子节点[l,mid],有子区间为[mid+1,r] 上图展示了一棵线段树。数的深度为logN，我们可以按照与二叉堆类似的“父子2倍”节点编号方法： 1.根节点编号为1. 2.编号为x的节点左子...
线段树（区间求和，区间加，单点更新等）
小` pi孩
12-23 424
线段树 线段树是一种二叉搜索树。它将一段区间划分为若干个单位区间，每一个节点都储存着一个区间。 线段树可做 区间求和，区间最值，区间更新，单点更新等操作 以区间和为例来做介绍： 建树 const int maxn=1000000+5; struct Tree{ int l,r; int val; int lazy,tag;//标记，需要区间更新时使用 }tree[maxn...
Interval GCD（线段树区间增加、区间查询）
hwdn3000的博客
03-09 960
题目描述 给定一个长度为N的数列A，以及M条指令 (N≤5*10^5, M<=10^5)，每条指令可能是以下两种之一： “C l r d”，表示把 A[l],A[l+1],…,A[r] 都加上 d。 “Q l r”，表示询问 A[l],A[l+1],…,A[r] 的最大公约数(GCD)。 输入 第一行两个整数N,M，第二行N个整数Ai，接下来M行每条指令的格式如题目描述所示。 输出 对于每个...
【数据结构】线段树算法总结（单点修改）
一个重视算法和系统设计的实战派
12-20 726
【代码总结】线段树算法总结（单点修改）
线段树经典操作模板(单点更新，替换；区间更新，替换；区间求和求最值)
NK_test的博客
08-09 3394
对于线段树的讲解此篇不再赘述，下面列出线段树应用中最常用的几种操作的代码。（具体题目未贴出，仅供有一定基础者参考代码风格） 另外，注意多组输入要写scanf("%d%d",&n,&m)!=EOF,线段树的题肯定要用c语言的输入输出，要使用字符数组，不用字符串，输入字符的时候要加getchar（）吞噬空行.. （1）单点增减，区间求和： #include #include #include #
线段树（单点查询+区间求和）无lazy标记
01-20
原理就大概如图所示，线段树的每个节点都是原数组的一段区间和，而叶子节点就是原数组对应 的值 建树代码： void build(int p,int lf,int rt){//建树 ans[p]=0; if(lf==rt) { ans[p]=A[lf]; return ; } int mid...
线段树Java实现-SegmentTree
最新发布
05-01
线段树Java实现——SegmentTree.txt 与文章中的讲解一致，几乎每句代码均有注释 阅读更方便，详细解析线段树 以区间求和为例进行代码的书写和解析。
统计的力量-线段树全接触-张昆玮
05-10
在某些情况下，线段树可能会退化为“点树”，即最底层的区间只包含一个点。尽管如此，处理方式不变，不影响线段树的效率。 线段树与前缀和的关系密切，对于区间和的查询，可以直接利用前缀和进行O(1)的计算。然而，...
线段树模板
02-03
线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的...
自己写的线段树的模板_
09-20
c++的线段树模板
HDU 1698 线段树-区间替换以及区间求和
weixin_34343308的博客
11-05 122
Just a Hook Time Limit: 4000/2000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 33883Accepted Submission(s): 16535 Problem Description In the game of D...
线段树--区间乘法和区间加法
weach的博客
05-11 1577
A Simple Problem with Integers 区间查询，区间修改 //#include<bits/stdc++.h> #include<iostream> using namespace std; template <typename T> void debug(string s, T x) { cout << s << "=" << x << "\n"; } typedef long long ll; ty
线段树大合集
m0_50435987的博客
11-06 116
1.最大数 #include <iostream> #include <cstdio> #include <cstring> #include <algorithm> using namespace std; typedef long long ll; const int N = 200005; int m,p; struct Tree{ int l,r; int v; //最大值属性. }tr[N * 4]; void push.
线段树（区间数）模板
qq_40293424的博客
11-04 109
建树模板 static void build_tree(int node,int start,int end){//建立线段树 if(start==end){//递归终止条件，树范围为1，直接将值赋值给叶节点 tree[node]=arr[start]; return; } int mid=(start+end)>>1;//划分左右子树的范围 in...
线段树（单点修改，区间查询）
orz
03-26 1998
引入 题目描述题目描述题目描述 10000个正整数，编号从1到10000，用A[1],A[2],A[10000]表示。 修改：1.将第L个数增加C （1 <= L <= 10000） 统计：1.编号从L到R的所有数之和为多少？ 其中1<= L <= R <= 10000. ...
线段树模板（区间修改）——hdu1698
zfldongcidaci的博客
10-09 1811
题目链接：https://vjudge.net/problem/HDU-1698 题目意思：有T组样例，每组样例给出n个棍子，开始棍子价值都是1，给出q个操作，可以把编号【x，y】之间的棍子的值改为z（z可以是1,2,3），求最终总价值。 分析：线段树区间修改，比较点修改，多了一个addv数组，该数组的意义在于可以记录修改的值。注意理解一个区间内其和为addv[rt]*（l-r+1），意义是改变
敌兵布阵 简单的线段树单点修改 + 单点查询
热爱编程，热爱技术
12-06 1196
A - 敌兵布阵   简单的线段树单点查询， 单点修改 AC代码： #include #include #include #include #include #include #include using namespace std; const int maxn = 50005; int n, people[maxn], sum[maxn <<
线段树（单点修改+区间查询）
Cauchy的博客
05-04 309
【模板】树状数组 1 文章目录题目描述题解 题目描述 如题，已知一个数列，你需要进行下面两种操作： 将某一个数加上 x{x}x 求出某区间每一个数的和 输入格式： 第一行包含两个正整数，分别表示该数列数字的个数和操作的总个数。 第二行包含 n{n}n 个用空格分隔的整数，其中第 i{i}i 个数字表示数列第 i{i}i 项的初始值。 接下来 m{m}m 行每行包含 3{3}3 个整数，表示一个操作，具体如下： 1 x k含义：将第 x{x}x 个数加上 k{k}k 2 x y含义：输出区间
ACM_线段树模板(单点更新)
知足常乐的博客
08-14 702
#define maxn 1000001 //const int maxn = 100001; int sum[maxn];void update(int root) //单节点更新 { sum[root] = sum[root<<1] + sum[root<<1|1]; } void build(int left, int right, int root) //建树 {
线段树区间修改后能否查询单点值
07-28
回答: 线段树区间修改后仍然可以查询单点值。在线段树中，每个节点都维护了一个标记值add，表示区间内所有数加上了add，并且维护了区间内所有数的和sum。当进行区间修改时，我们可以将区间拆分为O(logn)个小区间，并...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值