【线段树 小模板】

最新推荐文章于 2022-12-06 13:03:54 发布
最新推荐文章于 2022-12-06 13:03:54 发布
阅读量533 收藏 1
点赞数
分类专栏： 算法与有趣代码--记录 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenzhenyu123456/article/details/49764635
版权

花点时间写了线段树小模板，区间合并、覆盖、异或种类比较多，重在变换，模板就不写了。

一、单点更新，查询区间最大值、区间最小值、区间和。


#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <vector>
#define INF 0x3f3f3f3f
#define eps 1e-8
#define MAXN (3000+10)
#define MAXM (50000000)
#define Ri(a) scanf("%d", &a)
#define Rl(a) scanf("%lld", &a)
#define Rf(a) scanf("%lf", &a)
#define Rs(a) scanf("%s", a)
#define Pi(a) printf("%d\n", (a))
#define Pf(a) printf("%lf\n", (a))
#define Pl(a) printf("%lld\n", (a))
#define Ps(a) printf("%s\n", (a))
#define W(a) while(a--)
#define CLR(a, b) memset(a, (b), sizeof(a))
#define MOD 1000000007
#define LL long long
#define lson o<<1, l, mid
#define rson o<<1|1, mid+1, r
#define ll o<<1
#define rr o<<1|1
using namespace std;
struct Tree
{
    int l, r;
    int sum, Max, Min;
};
Tree tree[MAXN<<2];
void PushUp(int o)
{
    tree[o].sum = tree[ll].sum + tree[rr].sum;
    tree[o].Max = max(tree[ll].Max, tree[rr].Max);
    tree[o].Min = min(tree[ll].Min, tree[rr].Min);
}
void build(int o, int l, int r)
{
    tree[o].l = l, tree[o].r = r;
    if(l == r)
    {
        int a; scanf("%d", &a);
        tree[o].sum = tree[o].Max = tree[o].Min = a;
        return ;
    }
    int mid = (l + r) >> 1;
    build(lson);
    build(rson);
    PushUp(o);
}
void update(int o, int pos, int val)
{
    if(tree[o].l == tree[o].r)
    {
        tree[o].sum = tree[o].Max = tree[o].Min = val;
        return ;
    }
    int mid = (tree[o].l + tree[o].r) >> 1;
    if(pos <= mid)
        update(ll, pos, val);
    else
        update(rr, pos, val);
    PushUp(o);
}
int Query(int o, int L, int R, char *op)
{
    if(L <= tree[o].l && R >= tree[o].r)
    {
        if(strcmp(op, "Max") == 0)
            return tree[o].Max;
        else if(strcmp(op, "Min") == 0)
            return tree[o].Min;
        else
            return tree[o].sum;
    }
    int mid = (tree[o].l + tree[o].r) >> 1;
    if(R <= mid)
        return Query(ll, L, R, op);
    else if(L > mid)
        return Query(rr, L, R, op);
    else
    {
        if(strcmp(op, "Max") == 0)
            return max(Query(ll, L, mid, op), Query(rr, mid+1, R, op));
        else if(strcmp(op, "Min") == 0)
            return min(Query(ll, L, mid, op), Query(rr, mid+1, R, op));
        else
            return Query(ll, L, mid, op) + Query(rr, mid+1, R, op);
    }
}
int main()
{
    int N, Q;
    while(scanf("%d%d", &N, &Q) != EOF)
    {
        build(1, 1, N);
        while(Q--)
        {
            char op[5]; int x, y;
            scanf("%s%d%d", op, &x, &y);
            //U x y  —— 更新x位置元素为y
            //Max x y—— 查询区间[x, y]最大值
            //Min x y—— 查询区间[x, y]最小值
            //sum x y—— 查询区间[x, y]之和
            if(op[0] == 'U')
                update(1, x, y);
            else
                printf("%d\n", Query(1, x, y, op));
        }
    }
    return 0;
}

二、区间加、减更新 + 查询区间最大值、区间最小值、区间和。  


#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <vector>
#define INF 0x3f3f3f3f
#define eps 1e-8
#define MAXN (3000+10)
#define MAXM (50000000)
#define Ri(a) scanf("%d", &a)
#define Rl(a) scanf("%lld", &a)
#define Rf(a) scanf("%lf", &a)
#define Rs(a) scanf("%s", a)
#define Pi(a) printf("%d\n", (a))
#define Pf(a) printf("%lf\n", (a))
#define Pl(a) printf("%lld\n", (a))
#define Ps(a) printf("%s\n", (a))
#define W(a) while(a--)
#define CLR(a, b) memset(a, (b), sizeof(a))
#define MOD 1000000007
#define LL long long
#define lson o<<1, l, mid
#define rson o<<1|1, mid+1, r
#define ll o<<1
#define rr o<<1|1
using namespace std;
struct Tree
{
    int l, r, len;//区间左右端点 区间长度
    int sum, Max, Min;
    int lazy;//延迟标记
};
Tree tree[MAXN<<2];
void PushUp(int o)
{
    tree[o].sum = tree[ll].sum + tree[rr].sum;
    tree[o].Max = max(tree[ll].Max, tree[rr].Max);
    tree[o].Min = min(tree[ll].Min, tree[rr].Min);
}
void PushDown(int o)
{
    if(tree[o].lazy)
    {
        tree[ll].lazy += tree[o].lazy;
        tree[rr].lazy += tree[o].lazy;
        tree[ll].Max += tree[o].lazy;
        tree[rr].Max += tree[o].lazy;
        tree[ll].Min += tree[o].lazy;
        tree[rr].Min += tree[o].lazy;
        tree[ll].sum += tree[o].lazy * tree[ll].len;
        tree[rr].sum += tree[o].lazy * tree[rr].len;
        tree[o].lazy = 0;
    }
}
void build(int o, int l, int r)
{
    tree[o].l = l, tree[o].r = r;
    tree[o].len = r-l+1;
    tree[o].lazy = 0;
    if(l == r)
    {
        int a; scanf("%d", &a);
        tree[o].sum = tree[o].Max = tree[o].Min = a;
        return ;
    }
    int mid = (l + r) >> 1;
    build(lson);
    build(rson);
    PushUp(o);
}
void update(int o, int L, int R, int v)
{
    if(L <= tree[o].l && R >= tree[o].r)
    {
        tree[o].lazy += v;
        tree[o].Max += v; tree[o].Min += v;
        tree[o].sum += v * tree[o].len;
        return ;
    }
    PushDown(o);
    int mid = (tree[o].l + tree[o].r) >> 1;
    if(R <= mid)
        update(ll, L, R, v);
    else if(L > mid)
        update(rr, L, R, v);
    else
    {
        update(ll, L, mid, v);
        update(rr, mid+1, R, v);
    }
    PushUp(o);
}
int Query(int o, int L, int R, char *op)
{
    if(L <= tree[o].l && R >= tree[o].r)
    {
        if(strcmp(op, "Max") == 0)
            return tree[o].Max;
        else if(strcmp(op, "Min") == 0)
            return tree[o].Min;
        else
            return tree[o].sum;
    }
    PushDown(o);
    int mid = (tree[o].l + tree[o].r) >> 1;
    if(R <= mid)
        return Query(ll, L, R, op);
    else if(L > mid)
        return Query(rr, L, R, op);
    else
    {
        if(strcmp(op, "Max") == 0)
            return max(Query(ll, L, mid, op), Query(rr, mid+1, R, op));
        else if(strcmp(op, "Min") == 0)
            return min(Query(ll, L, mid, op), Query(rr, mid+1, R, op));
        else
            return Query(ll, L, mid, op) + Query(rr, mid+1, R, op);
    }
}
int main()
{
    int N, Q;
    while(scanf("%d%d", &N, &Q) != EOF)
    {
        build(1, 1, N);
        while(Q--)
        {
            char op[5]; int x, y, v;
            scanf("%s", op);
            //U x y v —— [x, y]元素全加v
            //Max x y—— 查询区间[x, y]最大值
            //Min x y—— 查询区间[x, y]最小值
            //sum x y—— 查询区间[x, y]之和
            if(op[0] == 'U')
            {
                scanf("%d%d%d", &x, &y, &v);
                update(1, x, y, v);
            }
            else
            {
                scanf("%d%d", &x, &y);
                printf("%d\n", Query(1, x, y, op));
            }
        }
    }
    return 0;
}



三、区间修改 + 查询区间最大值、区间最小值、区间和。 


#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <vector>
#define INF 0x3f3f3f3f
#define eps 1e-8
#define MAXN (3000+10)
#define MAXM (50000000)
#define Ri(a) scanf("%d", &a)
#define Rl(a) scanf("%lld", &a)
#define Rf(a) scanf("%lf", &a)
#define Rs(a) scanf("%s", a)
#define Pi(a) printf("%d\n", (a))
#define Pf(a) printf("%lf\n", (a))
#define Pl(a) printf("%lld\n", (a))
#define Ps(a) printf("%s\n", (a))
#define W(a) while(a--)
#define CLR(a, b) memset(a, (b), sizeof(a))
#define MOD 1000000007
#define LL long long
#define lson o<<1, l, mid
#define rson o<<1|1, mid+1, r
#define ll o<<1
#define rr o<<1|1
using namespace std;
struct Tree
{
    int l, r, len;//区间左右端点 区间长度
    int sum, Max, Min;
    int lazy;//延迟标记
};
Tree tree[MAXN<<2];
void PushUp(int o)
{
    tree[o].sum = tree[ll].sum + tree[rr].sum;
    tree[o].Max = max(tree[ll].Max, tree[rr].Max);
    tree[o].Min = min(tree[ll].Min, tree[rr].Min);
}
void PushDown(int o)
{
    if(tree[o].lazy != -1)
    {
        tree[ll].lazy = tree[o].lazy;
        tree[rr].lazy = tree[o].lazy;
        tree[ll].Max = tree[o].lazy;
        tree[rr].Max = tree[o].lazy;
        tree[ll].Min = tree[o].lazy;
        tree[rr].Min = tree[o].lazy;
        tree[ll].sum = tree[o].lazy * tree[ll].len;
        tree[rr].sum = tree[o].lazy * tree[rr].len;
        tree[o].lazy = -1;
    }
}
void build(int o, int l, int r)
{
    tree[o].l = l, tree[o].r = r;
    tree[o].len = r-l+1;
    tree[o].lazy = -1;
    if(l == r)
    {
        int a; scanf("%d", &a);
        tree[o].sum = tree[o].Max = tree[o].Min = a;
        return ;
    }
    int mid = (l + r) >> 1;
    build(lson);
    build(rson);
    PushUp(o);
}
void update(int o, int L, int R, int v)
{
    if(L <= tree[o].l && R >= tree[o].r)
    {
        tree[o].lazy = v;
        tree[o].Max = v; tree[o].Min = v;
        tree[o].sum = v * tree[o].len;
        return ;
    }
    PushDown(o);
    int mid = (tree[o].l + tree[o].r) >> 1;
    if(R <= mid)
        update(ll, L, R, v);
    else if(L > mid)
        update(rr, L, R, v);
    else
    {
        update(ll, L, mid, v);
        update(rr, mid+1, R, v);
    }
    PushUp(o);
}
int Query(int o, int L, int R, char *op)
{
    if(L <= tree[o].l && R >= tree[o].r)
    {
        if(strcmp(op, "Max") == 0)
            return tree[o].Max;
        else if(strcmp(op, "Min") == 0)
            return tree[o].Min;
        else
            return tree[o].sum;
    }
    PushDown(o);
    int mid = (tree[o].l + tree[o].r) >> 1;
    if(R <= mid)
        return Query(ll, L, R, op);
    else if(L > mid)
        return Query(rr, L, R, op);
    else
    {
        if(strcmp(op, "Max") == 0)
            return max(Query(ll, L, mid, op), Query(rr, mid+1, R, op));
        else if(strcmp(op, "Min") == 0)
            return min(Query(ll, L, mid, op), Query(rr, mid+1, R, op));
        else
            return Query(ll, L, mid, op) + Query(rr, mid+1, R, op);
    }
}
int main()
{
    int N, Q;
    while(scanf("%d%d", &N, &Q) != EOF)
    {
        build(1, 1, N);
        while(Q--)
        {
            char op[5]; int x, y, v;
            scanf("%s", op);
            //U x y v —— [x, y]元素变为v 注意v>=0
            //Max x y—— 查询区间[x, y]最大值
            //Min x y—— 查询区间[x, y]最小值
            //sum x y—— 查询区间[x, y]之和
            if(op[0] == 'U')
            {
                scanf("%d%d%d", &x, &y, &v);
                update(1, x, y, v);
            }
            else
            {
                scanf("%d%d", &x, &y);
                printf("%d\n", Query(1, x, y, op));
            }
        }
    }
    return 0;
}


随手写的，有bug的地方还请指出。

笑着走完自己的路
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自己写的线段树的模板_
09-20
c++的线段树模板
线段树模板
听取WA声一片
10-28 1744
线段树 打标记
线段树模板（Java）
Easenyang的博客
12-06 2294
  线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。它的主要优势是对于区间求和、区间求最大值、区间修改和单点修改的速度快，时间复杂度能达到O(logN)O(logN)O(logN)。   若以常规的方法在数组中进行区间求和等操作，时间复杂度会达到O(n)O(n)O(n)，若操作的次数量非常大，那么就很容易超时。线段树的优势就体现出来了   线段树的实现基于一维数组，用数组下标 2∗k+12 * k +12∗k+1 的元素代表左儿子，用下标 2∗k+
简单线段树模板
Marcus-Bao的个人主页
09-19 1355
例如:   给你任意几个数,给定N个区间,让你求这个区间的和;简单线段树的运用,帮助我更好的理解线段树,             //线段树基本 #include #define MAXN 100100 #define MINN 10000100 int  num[MAXN],t[MINN]; void build(int L,int R,int d) {      if(L==R)
线段树的四种模板
lhm的博客
07-20 3718
第一种模板只适合单点修改的题目，每次修改都传递到树的子节点。对于区间修改则不合适，同时，由于数组大小事先申明好，其点数也有上限。为了解决数据量的问题，这里提供了动态开点，解除了每个树的元素都占一个固定坑位的限制。但是仍然有限制，点数不可以随便加，有上限。和第一套模板相比，增加了区间修改的功能。但是点数仍然有上限，数据量顶多十万，再往上就不能适用了。点数无限制，需要的时候申请，但是效率会很低。...
线段树【模板】及解释
CZ_WangJunpeng的博客
10-01 1120
众所周知，线段树是一种十分狗好用的算法。 线段树是通过一颗
线段树[模板]
Le Petit Prince
11-02 289
前言线段树是一个非常实用的数据结构， 并且使用频率非常高. 所有操作都能在log时间内完成， 虽然常数要比树状数组大， 但是比起很多平衡树来说常数还是小了不少. 线段树的应用范围很广， 许多操作都能够支持. 关键是， 线段树好写好调， 完全不恶心. 除非操作非常简单， 尽量不要用树状数组. 线段树虽然代码要比树状数组大但还是很好写的， 关键是线段树要比树状数组应用范围广的多. 关于区间操作尽量用
线段树分裂/合并模板
平凡人Kalzn的博客
02-12 554
模板链接 最早从zx神仙口中得知这个玩意,但是一直没学,现在学一下再说,发现不是什么神仙东西,说实话有点小失落.按照区间分裂可以在O(logn)O(logn)O(logn)内完成,不过,合并操作需要枚举线段树的每个点进行合并,效率不是太高,数据量1e3差不多就是极限了.且应用面不是很广. 洛谷所给的模板是多个权值线段树的维护操作. 下面是模板代码: #include <iostream&g...
线段树模板&&树状数组模板
海马有力量的博客
07-21 330
书上的和网上的不一样，这个快一些，书上的不全，改了一点了。 #include<stdio.h> #include<string.h> #include<math.h> #define maxn 105 int a[maxn],ans; struct node{ int l,r,value,add; }tree[maxn]; void build(int v,i...
线段树模板整理
歪歪T的拿金之路
04-10 7807
综述线段树的原理：将[1,n]分解成若干特定的子区间(数量不超过4*n),然后，将每个区间[L,R]都分解为少量特定的子区间，通过对这些少量子区间的修改或者统计，来实现快速对[L,R]的修改或者统计。 作用：对编号连续的一些点的区间信息进行修改或者统计操作 主要操作：区间查询、点更新、区间更新 时间复杂度：修改和统计的复杂度都是O(log(N))由原理可以看出线段树维护的信息必须满足区间加法
C++ 线段树概念详解及模板
qq_44013342的博客
01-15 4689
前言 当你遇到有一些类似线性查找的题的时候，刚好数据特别大的时候，那么线段树这个东西就很好用了，但是线段树的概念就是学习线段树的一大难点，要想学好线段树，就要先了解线段树。 线段树的概念 1. 线段树是一棵二叉树，其节点表示的是一个区间 [ x , y ] 2.每一个叶子节点表示了一个单位区间，根节点表示的是“整体”的区间。 3. 每个非叶子节点的区间 [ x , y ] ...
线段树（模板+例题——郭神）
02-17
线段树（模板+例题——郭神） 私用，随意拿！
线段树模版（比较基本的线段树以及例题模板）
11-01
关于一些典型的线段树的例题，大家可以看一看，给一个评价，这些内容，后续我也会在博客上慢慢更新。希望大家多多的支持作者，谢谢！ 这篇内容主要包含了一些我写的线段树的代码，可以帮助大家更好的理解线段树建树...
线段树乘法模板（从基础线段树扩展）
最新发布
04-22
以下是针对标题为“完整的线段树模板，基础模板”的资源描述，但特别强调了线段树乘法的应用： 资源标题：完整的线段树模板，基础模板（含乘法操作） 资源描述： 线段树（Segment Tree）是一种强大的数据结构，...
欧拉图——欧拉通路和欧拉回路
热门推荐
世界很大
03-07 1万+
定义： 欧拉通路 (欧拉迹):通过图中每条边且只通过一次，并且经过每一顶点的通路。 欧拉回路 (欧拉闭迹):通过图中每条边且只通过一次，并且经过每一顶点的回路。 欧拉图:存在欧拉回路的图。 简单说欧拉通路就是首尾不相接，而欧拉回路要求首尾相接。   无向图是否具有欧拉通路或回路的判定: 欧拉通路:图连通；图中只有2个度为奇数的节点(就是欧拉通路的2个端点) 欧拉回路:图连通；图中所
LCA 转 RMQ算法 【总结】
世界很大
08-08 4362
首先，在你看这个算法之前，要确保你理解了RMQ的 ST 算法。 但是不理解没关系啊，提供通道：  点我 声明：这是方便我以后复习用的，所以总结不是特别详细。 LCA - 最近公共祖先：在有根树中，两个节点u和v的公共祖先中距离最近的那个点。 上图理解： 如图，我们想要求出LCA（4，7），LCA（8，6），LCA（5，8）。 用LCA转R
最小树形图 之 朱刘算法【模板】
世界很大
08-26 4355
定义：一个有向图，存在从某个点为根的，可以到达所有点的一个最小生成树，则它就是最小树形图。 朱刘算法实现过程： 【在选出入边集后（看步骤1），若有向图中不存在有向环，说明该图就是最小树形图】 1，选入边集——找到除root点之外，每一个点的所有入边中权值最小的，用数组in[]记录下这个最小权值，用pre[]记录到达该点的前驱；（若图中存在独立点，最小树形图是不存在的，所
最小费用最大流 【模板】
世界很大
08-24 3974
如果理解了最大流连续增广路算法的思维， 理解这个算法还是很简单的。 结构体存储信息： 分别为边的起点、终点、容量、当前流量、费用、下一条边的编号。 struct Edge { int from, to, cap, flow, cost, next; }; Edge edge[MAXM]; int head[MAXN], edgenum; 算法实现过程： 1
线段树python模板
08-14
下面是一个简单的线段树的 Python 实现模板： ```python class SegmentTree: def __init__(self, arr): self.arr = arr ...注意，这只是一个简单的线段树模板，可以根据具体问题的需求进行适当修改和扩展。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值