线段树__

最新推荐文章于 2024-08-03 18:36:56 发布
最新推荐文章于 2024-08-03 18:36:56 发布
阅读量48 收藏
点赞数
分类专栏： 数据结构 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63851154/article/details/127722821
版权

目录

单点修改+区间查询

线段树1（最小值+出现次数）

线段树2（最大子段和）

区间修改+区间查询

线段树打标记1（最大值）

线段树打标记2（子段和取mod）

单点修改+区间查询

线段树1（最小值+出现次数）

题解：

       需使用数据用 info 封装起来，便于修改维护，运算符 + 重载

        seg[N]记录路线段树节点

        update(id)：id编号的子树发生了变化，所以更新id这个节点的信息，build 和 change 中需要                             update 向上更新（建完左右子树后）

        change：单点修改 a[pos]->val

        query：[ l , r ]区间查询

        根据需要修改info，+，update，build和change中队seg[id]

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define lson id*2,l,m
#define rson id*2+1,m+1,r
const int N = 2e5+5;
int n, q, a[N];
struct info {
	int minv, mincut;
};
info operator+(const info& a, const info& b) {
	info x;
	if (a.minv < b.minv)x = a;
	else if (b.minv < a.minv)x = b;
	else x.minv = a.minv, x.mincut = a.mincut + b.mincut;
	return x;
}
struct node {
	info val;
}seg[N * 4];

void update(int id) {//向上更新
	seg[id].val = seg[id * 2].val + seg[id * 2 + 1].val;
}
void build(int id, int l, int r) {//建树
	if (l == r) {
		seg[id] = { a[l],1 };
		return;
	}int m = (l + r) / 2;
	build(lson);
	build(rson);
	update(id);//！
}
void change(int id, int l, int r, int pos, int val) {//单点修改
	if (l == r) {
		seg[id].val = {val,1};
		return;
	}
	int m = (l + r) / 2;
	if (pos<=m) change(lson, pos, val);
	else change(rson, pos, val);
	update(id);//！
}
info query(int id, int l, int r, int ql, int qr) {//区间查询
	if (ql == l && qr == r) {
		return seg[id].val;
	}int m = (l + r) / 2;
	if (qr <= m)return query(lson, ql, qr);
	else if (ql > m)return query(rson, ql, qr);
	else return query(lson, ql, m) 
		+ query(rson, m+1, qr);
}

int main() {
	scanf("%d%d", &n, &q);
	for (int i = 1; i <= n; i++) {
		scanf("%d", &a[i]);
	}
	build(1, 1, n);
	while (q--) {
		int tx; scanf("%d", &tx);
		if (tx == 1) {
			int x, d; scanf("%d%d", &x, &d);
			change(1, 1, n, x, d);
		}
		else {
			int l, r; scanf("%d%d", &l, &r);
			info ans = query(1, 1, n, l, r);
			printf("%d %d\n", ans.minv, ans.mincut);
		}
	}
	return 0;
}

线段树2（最大子段和）

题解：

        a[ i ]可能为负数，则区间前缀和或后缀和可能大于区间总和

        mss: max segment sum //区间最大子段和

        mpre  :  max prefix //最大前缀和

        msuf  :  max sufix //最大后缀和

        s  : sum //区间和（此题未用到）

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define lson id*2,l,m
#define rson id*2+1,m+1,r
const int N = 2e5 + 5;
int n, q, a[N];
struct info {
    ll mss, mpre, msuf, s;
    info() {}
    info(int val) :mss(val), mpre(val), msuf(val), s(val) {}
};
info operator + (const info& l, const info& r) {
    info a;
    a.mss = max({ l.mss, r.mss, l.msuf + r.mpre });
    a.mpre = max(l.mpre, l.s + r.mpre);
    a.msuf = max(r.msuf, r.s + l.msuf);
    a.s = l.s + r.s;
    return a;
}
struct node {
    info val;
}seg[N * 4];

void update(int id) {
    seg[id].val = seg[id * 2].val + seg[id * 2 + 1].val;
}
void build(int id, int l, int r) {
    if (l == r) {
        seg[id].val = info(a[l]);
        return;
    }
    int m = (l + r) / 2;
    build(lson);
    build(rson);
    update(id);//!
}

void change(int id, int l, int r, int pos, int val) {
    if (l == r) {
        seg[id].val = info(val);
        return;
    }
    int m = (l + r) / 2;
    if (pos <= m) change(lson, pos, val);
    else change(rson, pos, val);
    update(id);//!
}

info query(int id, int l, int r, int ql, int qr) {
    if (ql == l && qr == r) {
        return seg[id].val;
    }
    int m = (l + r) / 2;
    if (qr <= m) return query(lson, ql, qr);
    else if (ql > m) return query(rson, ql, qr);
    else return query(lson, ql, m) +
        query(rson, m + 1, qr);
}
int main() {
    scanf("%d %d", &n, &q);
    for (int i = 1; i <= n; ++i)
        scanf("%d", &a[i]);
    build(1, 1, n);
    while (q--) {
        int ty; scanf("%d", &ty);
        if (ty == 1) {
            int pos, val; scanf("%d %d", &pos, &val);
            change(1, 1, n, pos, val);
        }
        else {
            int l, r; scanf("%d %d", &l, &r);
            info ans = query(1, 1, n, l, r);
            printf("%lld\n", ans.mss);
        }
    }
    return 0;
}

区间修改+区间查询

线段树打标记1（最大值）

题解：

        settag(id)：给id这个节点打标记，同时节点的信息发生变化

         update(id)：id编号的子树发生了变化，所以更新id这个节点的信息，build 和 modify 中需要                             update 向上更新（建完左右子树后）

        pushdown(id)：将id节点的标记下传给子节点，区间修改 modify 和区间查询 query 中传递到                              子节点前进行

        modify：[ l , r ]区间修改

注意tag要开ll ，因为标记可能叠加（不着急传到子节点）

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define lson id*2,l,m
#define rson id*2+1,m+1,r
const int N = 2e5 + 5;
int n, q, a[N];
struct node {
    ll t, val;
}seg[N * 4];

void update(int id) {
    seg[id].val = max(seg[id * 2].val , seg[id * 2 + 1].val);
}
void settag(int id, ll t) {
    seg[id].val += t;
    seg[id].t += t;
}
void pushdown(int id) {
    if (seg[id].t) {
        settag(id * 2, seg[id].t);
        settag(id * 2 + 1, seg[id].t);
        seg[id].t = 0;
    }
}
void build(int id, int l, int r) {
    if (l == r) {
        seg[id].val = a[l];
        return;
    }
    int m = (l + r) / 2;
    build(lson);
    build(rson);
    update(id);//!
}

void modify(int id, int l, int r, int ql, int qr,int t) {
    if (ql==l&&qr == r) {
        settag(id, t);
        return;
    }pushdown(id);
    int m = (l + r) / 2;
    if (qr <= m) modify(lson, ql, qr, t);
    else if (ql > m)modify(rson, ql, qr, t);
    else modify(lson, ql, m, t), 
        modify(rson, m + 1, qr, t);
    update(id);//!
}

ll query(int id, int l, int r, int ql, int qr) {
    if (ql == l && qr == r) {
        return seg[id].val;
    }pushdown(id);
    int m = (l + r) / 2;
    if (qr <= m) return query(lson, ql, qr);
    else if (ql > m) return query(rson, ql, qr);
    else return max(query(lson, ql, m) ,
        query(rson, m + 1, qr));
    //update(id);
}
int main() {
    scanf("%d %d", &n, &q);
    for (int i = 1; i <= n; ++i)
        scanf("%d", &a[i]);
    build(1, 1, n);
    while (q--) {
        int ty; scanf("%d", &ty);
        if (ty == 1) {
            int l, r, t; 
            scanf("%d%d%d", &l, &r, &t);
            modify(1, 1, n, l, r, t);
        }
        else {
            int l, r; scanf("%d%d", &l, &r);
            ll ans=query(1, 1, n, l, r);
            printf("%lld\n", ans);
        }
    }
    return 0;
}

线段树打标记2（子段和取mod）

题解：  

按常理来说，要有多个标记。但是多个标记太麻烦了，而且还要考虑先后顺序。所以就萌发出一种合并这3个标记的想法，在根据合并后的标记对区间和进行更新

struct tag { ll mul, add; };

  • +d  -> v*1+d   {1,d}
  • *d  -> v*d+0   {d,0}
  • 变成d -> v*0+d  {0, d}    

起始时，tag的每个tag的初始状态为(1,0)，即v*1+0

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define lson id*2,l,m
#define rson id*2+1,m+1,r
const int N = 2E5 + 5;
int n, q, a[N];
const int mod = 1e9 + 7;

struct tag {
	ll mul, add;
};
tag operator + (const tag& t1, const tag& t2) {
	// (mul1 + add1) * mul2 + add2;
	return { t1.mul * t2.mul % mod, (t1.add * t2.mul % mod + t2.add) % mod };
}
struct node {
	tag t;
	ll val;
	int sz;
}seg[N * 4];


void update(int id) {
	seg[id].val = (seg[id * 2].val + seg[id * 2 + 1].val) % mod;
}
void build(int id, int l, int r) {
	seg[id].t = (tag){ 1, 0 };
	seg[id].sz = r - l + 1;
	if (l == r) {
		seg[id].val = a[l];
	}
	else {
		int m = (l + r) / 2;
		build(lson);
		build(rson);
		update(id);
	}
}
void settag(int id, tag t) {
	seg[id].val = seg[id].val * t.mul % mod + seg[id].sz * t.add % mod;
	seg[id].t = seg[id].t + t;
}

void pushdown(int id) {
	if (seg[id].t.mul != 1 || seg[id].t.add != 0) {
		settag(id * 2, seg[id].t);
		settag(id * 2 + 1, seg[id].t);
		seg[id].t.mul = 1;
		seg[id].t.add = 0;
	}
}
void modify(int id, int l, int r, int ql, int qr, tag t) {
	if (l == ql && r == qr) {
		settag(id, t);
		return;
	}
	pushdown(id);
	int m = (l + r) / 2;
	if (qr <= m) modify(lson, ql, qr, t);
	else if (ql > m) modify(rson, ql, qr, t);
	else modify(lson, ql, m, t),
		modify(rson,  m + 1, qr, t);
	update(id);
}

ll query(int id, int l, int r, int ql, int qr) {
	if (l == ql && r == qr) {
		return seg[id].val;
	}
	pushdown(id);
	int m = (l + r) / 2;
	if (qr <= m) return query(lson, ql, qr);
	else if (ql > m) return query(rson, ql, qr);
	else return (query(lson, ql, m) +
		query(rson, m + 1, qr)) % mod;
}
int main() {
	scanf("%d %d", &n, &q);
	for (int i = 1; i <= n; ++i)
		scanf("%d", &a[i]);
	build(1, 1, n);
	while (q--) {
		int ty; scanf("%d", &ty);
		if (ty <= 3) {
			int l, r, d;
			scanf("%d %d %d", &l, &r, &d);
			if (ty == 1) modify(1, 1, n, l, r, (tag) { 1, d });
			else if (ty == 2) modify(1, 1, n, l, r, (tag) { d, 0 });
			else modify(1, 1, n, l, r, (tag) { 0, d });
		}
		else {
			int l, r; scanf("%d %d", &l, &r);
			printf("%lld\n", query(1, 1, n, l, r));
		}
	}
	return 0;
}
F_yx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【算法】线段树详解
_Alexander_的博客
08-20 5万+
线段树，是一种二叉搜索树。它功能强大，支持区间求和，区间最大值，区间修改，单点修改等操作。 它的时间复杂度是O(nlogn)的。 十分良心，欢迎阅读！
李超线段树
weach的博客
07-29 4061
什么是李超线段树 先以一个问题引入： 在平面上有两种操作（强制在线）： 插入一条表达式为 L : y = k*x+b 的直线，给出 k ,b 。 给出 t，求当前所有直线中与直线 x = t 交点的纵坐标最大是多少 直线取 max 应该是得到一个下凸包，像这样（黑色的）： 李超线段树是什么？线段树，当然是要维护区间 [L , R] 的一个信息，李超线段树维护的就是中点处最高的直线 比如下图，区间 [ 0 , 4 ] 的中点 x = 2 的最高直线为红色直线 利用这一信息，可以在 O(log n )
线段树_lazytag
一只懒猫的博客
08-01 611
1.lazytag是个结点的标记。 2.当需要使用线段树进行区间修改的时候，利用线段树存储区间信息的特点，在修改【L,R】区间时，如果区间【a，b】完全包括在【L,R】区间内，就给这个结点打上tag标记同时更新这个结点的值，tag标记的值就是区间需要修改的值。 3.当需要用到线段树进行区间查询的时候，如果查询到的结点有tag标记。就将tag标记分给子节点并更新子节点的值，同时清空自己的tag标记。 #include<iostream> using namespace std; const..
线段树_数据结构
ezoiHY
02-21 2930
没错则就是一个（过去的）线段树黑洞的线段树博客 线段树： 忠诚改 实际上这个线段树是十分的简（fu）单（za）的 分别有以下几个函数： build:构建整棵线段树 pushup:对于我们所要求的答案进行往上更新 pushdown:lazy标记下传 update:区间修改（可以当做单点修改用） query:区间查询（和，最值等） 所以这里每个节点可以维护一个值（如区间最值、和等...
秋招算法总结：线段树_树状数组_原理_区别_代码实现
weixin_41944387的博客
06-28 581
秋招算法总结：树状数组与线段树
线段树详解
orz
05-20 9930
1. 什么是线段树 顾名思义 ， 线段树是一棵二叉树 ， 但不同的是这棵树的结点储存的值是一个数列中 [l,r][l,r][l,r] 的某个需要的值 （例如，求和，求最大值，求最小值） 这是一棵典型的线段树 ，其性质是 ： 若其中一子节点编号为 aaa ， 则该节点左儿子编号为 2a2a2a ， 其右儿子编号为 2a+12a+12a+1 2. 线段树的用处 线段树的用处就是，对编号连续的一些点进行修改或者统计操作，修改和统计的复杂度都是 O(log2n)O(log_2 n)O(log2​n). 3.
线段树_逆序数
Confidence的专栏
03-15 1327
题目链接 分析： 对于输入序列ipt[]，每次先查询[ipt[i] + 1, max]区间和（在输入点之前比它大的数的个数）加到answer里边；然后对ipt[i]处加一。 这个题是求循环序列中逆序数最小的，那么当树中有n个数的时候，在需要插入数时就把第一个数删去。下边是自己的写法，比较麻烦 const int MAXN = 5100; #define lson l, m, rt
线段树segment_tree go语言实现
AndrewYZWang的博客
03-11 778
线段树(segment tree) 什么是线段树 线段树是一种二叉搜索树，什么叫做二叉搜索树，首先满足二叉树，每个结点度小于等于二，即每个结点最多有两颗子树，何为搜索，我们要知道，线段树的每个结点都存储了一个区间，也可以理解成一个线段，而搜索，就是在这些线段上进行搜索操作得到你想要的答案。 线段树是建立在线段的基础上，每个结点都代表了一条线段[a,b]。长度为1的线段称为元线段。非元线段都有两个子结点，左结点代表的线段为[a,(a + b) / 2]，右结点代表的线段为[((a + b) / 2）+1,b]
什么是线段树
ThinPikachu的博客
04-04 1708
线段树的概念 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2+1,b]。因此线段树是平衡二叉树，最后的子节点数目为N，即整个线段区间的长度。 线段树的应用 线段树 segmentTree 是一个二叉树，每个结点保存数组 nums 在区间 [left, right] 的最...
线段树练习题集
UncleJokerly
04-28 2260
线段树题目整合 1.hdu1166 敌兵布阵 更新节点,区间求和。 2.hdu1754 I Hate It 更新节点,区间最值. .3.hdu1698 Just a Hook 成段更新,总区间求和. .4.hdu1394 Minimum Inversion Number 更新节点,区间求和 .5.hdu1779（这个爆炸了，别做了） 成段更新,区间最值 .6.pku...
线段树_线段树_
10-01
线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的...
线段树_方泓杰.pdf
09-14
线段树是一种高效的数据结构，常用于处理动态区间查询和修改问题。它的核心思想是将一个数组分成多个重叠的子区间（线段），并将这些子区间的信息存储在一个树形结构中，通过分治策略来快速响应查询和更新操作。 在...
线段树_翁家翌 & 黄哲威.pdf
09-14
线段树是一种数据结构，主要用于高效地处理动态的区间查询和修改问题。它是由翁家翌和黄哲威等人在互联网领域中广泛讨论的一种技术。线段树的主要优点在于能够在线性时间内完成对大规模序列的预处理，并在之后对序列...
自己写的线段树的模板_
09-20
c++的线段树模板
pku2104.rar_线段树
09-23
线段树是一种高级的数据结构，常用于处理区间查询与修改问题。在计算机科学和算法设计中，线段树被广泛应用于动态维护区间信息，如求解区间最大值、最小值、求和等问题，且能在O(log n)的时间复杂度内完成操作。PKU...
OpenGL3.3_C++_Windows(32)
sengyongan的博客
07-29 409
demo SSAO SSAO 环境光照(Ambient Lighting)：光的散射，我们通过一个固定的常量作为环境光的模拟， 但是这种固定的环境光并不能很好模拟散射，因为环境光不是一成不变的， 环境光遮蔽：让（褶皱、孔洞）等变暗的方法近似模拟出间接光照，但是这一技术会带来很大的性能开销，因为它还需要考虑周围的几何体。 屏幕空间环境光遮蔽(Screen-Space Ambient Occlusion, SSAO)：这一技术使用了屏幕空间场景的深度而不是真实的几何体数据来确定遮蔽量。 原理：对
【C++】输入输出
2401_83948390的博客
08-02 493
在C++中，输入输出操作主要通过标准库中的iostream头文件提供的一系列对象和函数来完成。
二叉树的中序遍历 - 力扣（LeetCode）C语言
最新发布
SikJ_2020_0_24的博客
08-03 169
注：本题中returnSize，指的是二叉树的结点数，返回的必须是malloc开辟的。递归算法很简单，你可以通过迭代算法完成吗？注意要点与前序遍历相同，请参考。（点击前面链接即可查看题目）给定一个二叉树的根节点。
3.C_Demo_最大公约数、最小公倍数
Fresh_man111的博客
08-03 192
假设两个数字a和b，求两个数字相除的余数c=a%b，如果余数为0，则b为最大公约数。如果b不为零，a=b,b=c,继续循环计算。两个数的最小公倍数数等于两个数的乘积除以两个数的最大公约数。即：x，y的最小公倍数 min(公倍数)=x*y÷max(公约数)参数a，b：传入的两个数值，两个数都不能为0。参数a，b：传入的两个数值，不能全为0。返回值：0代表错误，正常返回最大公约数。返回值：0代表错误，正常返回最小公倍数。功能：求a，b最大公约数。功能：求a，b最小公倍数。
线段树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 下传给左右儿子节点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值