线段树讲解（小进阶）

已于 2025-05-01 10:09:36 修改
阅读量1k 收藏 29
点赞数 52
分类专栏： 数据结构与算法 文章标签： c++ 算法 开发语言 数据结构 c语言 线段树
于 2025-04-23 23:18:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_87734250/article/details/147464106
版权

目录

前言

一、线段树知识回顾

线段树区间加减

区间修改维护：

区间修改的操作：

区间修改update：

线段树的区间查询

区间查询：

区间查询的操作：

递归查询过程：

区间查询query：

代码：

二、线段树的区间修改---乘上一个数’x'

build

区间修改

update

mulpr_update

push_up

代码：

push_down

左：

右：

代码：

区间查询query

代码：

三、例题

例题：P3373 【模板】线段树 2 - 洛谷

​编辑

完整代码：

总结

前言

本篇文章主要是根据P3373 【模板】线段树 2 - 洛谷对线段树进行进一步的讲解

一、线段树知识回顾

我们在进一步学习前，先来看一下前置知识

开一个build函数建树，具体操作如下：

1.定义数组：首先，需要定义一个大小为 4n 的数组，其中 n 是线段树的叶子节点数量。这个数组将用于存储线段树的节点信息。

2.构建线段树：一般将线段树按照完全二叉树的形式存储在数组中。假设根节点在数组中的索引是 1，那么对于节点 i，其左子节点为 2i，右子节点为 2i + 1。

3.存储节点信息：每个节点需要保存代表的区间范围和相应的信息，比如区间的最大值、最小值、和等等。在数组中，可以按照某种顺序依次存储这些信息，以便后续的查询和更新操作。

4.建立线段树：通过递归或迭代的方式构建线段树。一般会从叶子节点开始向上构建，通过合并子节点的信息得到父节点的信息，直至构建完整的线段树。

5.查询和更新：通过线段树的结构和数组存储，可以实现高效的区间查询和更新操作。比如，对于查询一个区间的最大值，可以通过递归向下查询到包含目标区间的节点，并根据存储的信息计算出结果。

6.记得注意边界情况：在实现线段树时，需要考虑树的边界情况，比如树的根节点索引是 1，叶子节点索引从 n+1 开始等，以确保正确地访问和操作节点。

// 建树函数
void build(LL l, LL r, LL fa) {
    if (l == r) { // 如果区间只有一个元素
        t[fa] = a[l] % m; // 直接赋值
        return;
    }
    LL mid = (l + r) >> 1; // 计算中间节点
    build(l, mid, fa << 1); // 递归构建左子树
    build(mid + 1, r, fa << 1 | 1); // 递归构建右子树
    push_up(fa); // 更新父节点
}

线段树区间加减

区间修改维护：

1.需要修改线段树中某个特定区间的值时，可以通过递归的方式向下更新区间。
2.如果要修改的区间与当前节点表示的区间没有交集，则无需修改该节点。
3.如果要修改的区间完全包含当前节点的区间，则直接更新当前节点的信息，并将修改操作下传给子节点。
4.如果要修改的区间与当前节点的区间部分相交，则需要先将当前节点的信息更新，然后将修改操作同时下传给左右子节点。


区间修改的操作：


1.区间修改的操作通常包括加法、减法、赋值等。
2.当需要对区间内的每个元素进行相同的修改时，可以利用线段树的特性进行高效操作。
3.在修改区间时，需要根据当前节点的区间范围、待修改区间和修改方式来确定如何操作当前节点和其子节点。


递归更新过程：


从线段树的根节点开始递归向下更新，直到找到包含待修改区间的叶子节点。
在递归过程中根据节点的区间范围和待修改区间的关系，决定如何更新节点的信息并向下传递修改操作。
       此外，对于区间操作，我们考虑引入一个名叫“ lazy tag ”（懒标记）的东西——之所以称其“lazy”，是因为原本区间修改需要通过先改变叶子节点的值，然后不断地向上递归修改祖先节点直至到达根节点，时间复杂度最高可以到达 O(nlogn) 的级别。但当我们引入了懒标记之后，区间更新的期望复杂度就降到了 O(logn) 的级别且甚至会更低。

因此，我们再弄一个tag数组，大小也是4*N

区间修改update：

void psuh_up(LL fa) {
	t[fa] = t[fa << 1] + t[fa << 1 | 1];//向上不断维护父节点
}
void push_down(LL l,LL r,LL fa) {
	LL mid = (l + r) >> 1;
	t[fa << 1] += tag[fa] * (mid - l + 1);
	tag[fa << 1] += tag[fa];
	t[fa << 1|1] += tag[fa] * (r-mid);
	tag[fa << 1|1] += tag[fa];
	tag[fa] = 0;// //每次将懒惰标识下放到两个儿子节点，自身置为0，以此不断向下传递 
}
void update(LL ql, LL qr, LL l, LL r, LL k, LL fa) {
	
	if (ql <= l && qr >= r) //如果区间被包含，直接返回该节点的懒惰标识
	{
		t[fa] +=k * (r - l + 1);
		tag[fa] += k;
		return;
	}
	LL mid = (l + r) >> 1;
	push_down(l, r, fa);//下放懒惰标识
	if (ql <= mid)update(ql, qr, l, mid,k, fa << 1);//朝左边下放
	if (qr > mid)update(ql, qr, mid + 1, r,k, fa << 1 | 1);//右边
	psuh_up(fa);//再将修改后的值向上返回，维护父节点
}

我们这一期会对update和push_down进行更改

线段树的区间查询

  1. 区间查询：

    • 当需要查询线段树中某个特定区间的信息时，可以通过递归的方式向下查询区间。
    • 如果要查询的区间与当前节点表示的区间没有交集，则无需查询该节点，直接返回默认值（如0或无穷大）。
    • 如果要查询的区间完全包含当前节点的区间，则直接返回该节点存储的信息。
    • 如果要查询的区间与当前节点的区间部分相交，则需要同时查询左右子节点，并根据查询结果合并得到最终结果。

  2. 区间查询的操作：

    • 区间查询的操作通常包括求和、求最大值、求最小值等。
    • 在查询区间时，需要根据当前节点的区间范围、待查询区间和查询方式来确定如何操作当前节点和其子节点。

  3. 递归查询过程：

    • 从线段树的根节点开始递归向下查询，直到找到包含待查询区间的叶子节点。
    • 在递归过程中根据节点的区间范围和待查询区间的关系，决定如何查询节点的信息并向下传递查询操作。
    • 最终将所有查询结果合并得到最终的区间查询结果。

      通过以上方法，可以实现对线段树中特定区间的查询操作。线段树区间查询是线段树的一个重要功能，能够快速有效地获取区间内的信息，提高了区间查询的效率。

区间查询query：

LL query(LL ql, LL qr, LL l, LL r, LL fa) {
	LL ret = 0;
	if (ql <= l && qr >= r) 如果区间被包含，直接返回该节点的懒惰标识
	{
		return t[fa];
	}
	LL mid = (l + r) >> 1;
	push_down(l, r, fa);//没有被包含，下放任务
	if (ql <= mid)ret += query(ql, qr, l, mid, fa << 1);
	if (qr > mid)ret += query(ql, qr, mid + 1, r, fa << 1|1);
	//在查询范围的左区间和右区间的值相加并返回
	return ret;
}

代码：

#include<iostream>
using namespace std;
const int N = 1e5 + 10;
typedef long long LL;
LL n, m, t[N * 4], tag[N * 4], a[N];
void psuh_up(LL fa) {
	t[fa] = t[fa << 1] + t[fa << 1 | 1];//向上不断维护父节点
}
void push_down(LL l,LL r,LL fa) {
	LL mid = (l + r) >> 1;
	t[fa << 1] += tag[fa] * (mid - l + 1);
	tag[fa << 1] += tag[fa];
	t[fa << 1|1] += tag[fa] * (r-mid);
	tag[fa << 1|1] += tag[fa];
	tag[fa] = 0;// //每次将懒惰标识下放到两个儿子节点，自身置为0，以此不断向下传递 
}
LL query(LL ql, LL qr, LL l, LL r, LL fa) {
	LL ret = 0;
	if (ql <= l && qr >= r) 如果区间被包含，直接返回该节点的懒惰标识
	{
		return t[fa];
	}
	LL mid = (l + r) >> 1;
	push_down(l, r, fa);//没有被包含，下放任务
	if (ql <= mid)ret += query(ql, qr, l, mid, fa << 1);
	if (qr > mid)ret += query(ql, qr, mid + 1, r, fa << 1|1);
	//在查询范围的左区间和右区间的值相加并返回
	return ret;
}
void update(LL ql, LL qr, LL l, LL r, LL k, LL fa) {
	
	if (ql <= l && qr >= r) //如果区间被包含，更新懒惰标识并返回
	{
		t[fa] +=k * (r - l + 1);
		tag[fa] += k;
		return;
	}
	LL mid = (l + r) >> 1;
	push_down(l, r, fa);//下放懒惰标识
	if (ql <= mid)update(ql, qr, l, mid,k, fa << 1);//朝左边下放
	if (qr > mid)update(ql, qr, mid + 1, r,k, fa << 1 | 1);//右边
	psuh_up(fa);//再将修改后的值向上返回，维护父节点
}
void build(LL l, LL r, LL fa) {
	if (l == r) // //如果左右区间相同，那么必然是叶子节，只有叶子节点是被真实赋值的
	{
		t[fa] = a[l];
		return;
	}
	LL mid = (l + r) >> 1;

	build(l, mid, fa << 1);
	build(mid + 1, r, fa << 1 | 1);
	//使用二分来优化
	psuh_up(fa);//此处由于我们是要通过子节点来维护父节点，所以push_up的位置应当是在回溯时将子节点的值取和交给父节点
}
int main() {
	cin >> n >> m;
	for (int i = 1; i <= n; i++)cin >> a[i];
	build(1, n, 1);
	while (m--) {
		int op; cin >> op;
		if (op == 1) {
			LL x, y, k; cin >> x >> y >> k;
			update(x, y, 1, n, k, 1);
		}
		else if(op==2){
			LL x, y;
			cin >> x >> y;
			cout << query(x, y, 1, n, 1) << endl;
		}
	}
	return 0;
}

二、线段树的区间修改---乘上一个数’x'

老样子，先看题目

根据题目意思先建树

build：

代码：

// 建树函数
void build(LL l, LL r, LL fa) {
    if (l == r) { // 如果区间只有一个元素
        t[fa] = a[l] % m; // 直接赋值
        return;
    }
    LL mid = (l + r) >> 1; // 计算中间节点
    build(l, mid, fa << 1); // 递归构建左子树
    build(mid + 1, r, fa << 1 | 1); // 递归构建右子树
    push_up(fa); // 更新父节点
}

因为题目增加了一个区间乘一个数，所以我们需要维护两个tag数组，tag1，tag2，大小都是n*4；

令tag1为区间乘一个数的数组，由于区间乘一个数，所以数组tag1全部初始化为1；

代码：

int main() {
	cin >> n >>q>> m;
	for (int i = 0; i <= N * 4; i++)tag1[i] = 1;
	for (int i = 1; i <= n; i++)cin >> a[i];
	build(1, n, 1);
	while (q--) {
		int op; cin >> op;
		if (op == 2) {
			LL x, y, k; cin >> x >> y >> k;
			update(x, y, 1, n, 1, k%m);
		}
		else if (op == 3) {
			LL x, y; cin >> x >> y;
			cout << query(x, y, 1, n, 1)%m  << endl;
		}
		else if (op == 1) {
			LL x, y, k; cin >> x >> y >> k;
			mulpr_update(x, y, 1, n, 1, k);
		}
	}
	return 0;
}

这个模去m是题目要求的，后面不会去详细讲，只会说tag数组如何维护以及query的一点改动；

区间修改

需要两个不同的update来维护区间加和区间乘

区间加就不多赘述了

update

// 更新函数
void update(LL ql, LL qr, LL l, LL r, LL fa, LL k) {
    if (ql <= l && qr >= r) { // 如果更新区间完全覆盖当前区间
        t[fa] = (t[fa] + (r - l + 1) * k) % m; // 更新当前节点的值
        tag2[fa] = (tag2[fa] + k) % m; // 更新加法标记
        return;
    }
    LL mid = (l + r) >> 1; // 计算中间节点
    push_down(l, r, fa); // 向下更新标记
    if (ql <= mid) // 如果更新区间在左子树
        update(ql, qr, l, mid, fa << 1, k); // 更新左子树
    if (qr > mid) // 如果更新区间在右子树
        update(ql, qr, mid + 1, r, fa << 1 | 1, k); // 更新右子树
    push_up(fa); // 更新父节点
}

来看一下区间乘

如果要更新的区间覆盖了当前的区间，直接更新当前t数组的值，更新tag1，tag2的懒惰标识，然后return，就不需要下放懒惰标识了；

如果区间没有覆盖，puah_down下放懒惰标识，更新左边，然后更新右边，然后push_up向上更新父节点；

mulpr_update


// 乘法更新函数
void mulpr_update(LL ql, LL qr, LL l, LL r, LL fa, LL k) {
    if (ql <= l && qr >= r) { // 如果更新区间完全覆盖当前区间
        t[fa] = t[fa] * k % m; // 更新当前节点的值
        tag1[fa] = tag1[fa] * k % m; // 更新乘法标记
        tag2[fa] = tag2[fa] * k % m; // 更新加法标记
        return;
    }
    LL mid = (l + r) >> 1; // 计算中间节点
    push_down(l, r, fa); // 向下更新标记
    if (ql <= mid) // 如果更新区间在左子树
        mulpr_update(ql, qr, l, mid, fa << 1, k); // 更新左子树
    if (qr > mid) // 如果更新区间在右子树
        mulpr_update(ql, qr, mid + 1, r, fa << 1 | 1, k); // 更新右子树
    push_up(fa); // 更新父节点
}

push_up

代码：

// 向上更新函数，更新父节点的值
void push_up(LL fa) {
    // 父节点的值等于左右子节点的和，取模 m
    t[fa] = (t[fa << 1] + t[fa << 1 | 1]) % m;
}

push_down

比较有难度的一个push_down，如果思路清晰的话就会变得很简单

左：

先将需要下放懒惰标识的区间取mid，更新树t左子节点，用tag1和tag2 fa位置的懒惰值更新

然后更新tag1左子节点，因为是乘，所以将tag1fa父节点的懒惰标识乘上tag1[fa<<1]左子节点的懒惰标识更新该左子节点的懒惰标识

然后更新tag2左子节点，虽然是区间加的懒惰数组，但是tag1和tag2作用在同一个线段树，所以在更新tag2时需要看看tag1[fa]有没有懒惰标识，有的话得加上tag1[fa] * tag2[fa << 1]，即如果tag1有懒惰标识，将其乘上tag2左子节点[fa<<1]原本有的懒惰标识；

右：

更新树t右子节点，用tag1和tag2 fa位置的懒惰值更新

然后更新tag1右子节点，因为是乘，所以将tag1fa父节点的懒惰标识乘上tag1[fa<<1|1]右子节点的懒惰标识更新该左子节点的懒惰标识

然后更新tag2右子节点，虽然是区间加的懒惰数组，但是tag1和tag2作用在同一个线段树，所以在更新tag2时需要看看tag1[fa]有没有懒惰标识，有的话得加上tag1[fa] * tag2[fa << 1|1]，即如果tag1有懒惰标识，将其乘上tag2左子节点[fa<<1|1]原本有的懒惰标识；

最后因为懒惰标识已经下放，所以将fa节点的懒惰标识置为初始值，tag1置为1，tag2置为0；

代码：

// 向下更新函数，处理懒惰标记
void push_down(LL l, LL r, LL fa) {
    LL mid = (l + r) >> 1; // 计算中间节点
    // 更新左子节点
    t[fa << 1] = (tag1[fa] * t[fa << 1] % m + tag2[fa] * (mid - l + 1) % m) % m;
    tag1[fa << 1] = (tag1[fa << 1] * tag1[fa]) % m; // 更新乘法标记
    tag2[fa << 1] = (tag2[fa] + tag1[fa] * tag2[fa << 1] % m) % m; // 更新加法标记

    // 更新右子节点
    t[fa << 1 | 1] = (tag1[fa] * t[fa << 1 | 1] % m + (tag2[fa] * (r - mid)) % m) % m;
    tag1[fa << 1 | 1] = (tag1[fa << 1 | 1] * tag1[fa]) % m; // 更新乘法标记
    tag2[fa << 1 | 1] = (tag2[fa] + tag1[fa] * tag2[fa << 1 | 1] % m) % m; // 更新加法标记

    // 清空当前节点的标记
    tag1[fa] = 1;
    tag2[fa] = 0;
}

区间查询query

代码：

// 查询函数
LL query(LL ql, LL qr, LL l, LL r, LL fa) {
    LL ret = 0; // 初始化返回值
    if (ql <= l && qr >= r) { // 如果查询区间完全覆盖当前区间
        return t[fa] % m; // 返回当前节点的值
    }
    LL mid = (l + r) >> 1; // 计算中间节点
    push_down(l, r, fa); // 向下更新标记
    if (ql <= mid) // 如果查询区间在左子树
        ret = (ret + query(ql, qr, l, mid, fa << 1)) % m; // 查询左子树
    if (qr > mid) // 如果查询区间在右子树
        ret = (ret + query(ql, qr, mid + 1, r, fa << 1 | 1)) % m; // 查询右子树
    return ret % m; // 返回结果
}

三、例题

例题：P3373 【模板】线段树 2 - 洛谷

完整代码：


#include <iostream>
#include <cstring>
using namespace std;

// 定义常量 N，表示数组的最大大小
const int N = 1e5 + 10;

// 定义长整型别名 LL
typedef long long LL;

// 全局变量
LL n, m, q; // n: 数组大小, m: 模数, q: 查询次数
LL t[N * 4], a[N]; // t: 线段树数组, a: 原始数组
LL tag1[N * 4], tag2[N * 4]; // tag1: 乘法标记, tag2: 加法标记

// 向上更新函数，更新父节点的值
void push_up(LL fa) {
    // 父节点的值等于左右子节点的和，取模 m
    t[fa] = (t[fa << 1] + t[fa << 1 | 1]) % m;
}

// 向下更新函数，处理懒惰标记
void push_down(LL l, LL r, LL fa) {
    LL mid = (l + r) >> 1; // 计算中间节点
    // 更新左子节点
    t[fa << 1] = (tag1[fa] * t[fa << 1] % m + tag2[fa] * (mid - l + 1) % m) % m;
    tag1[fa << 1] = (tag1[fa << 1] * tag1[fa]) % m; // 更新乘法标记
    tag2[fa << 1] = (tag2[fa] + tag1[fa] * tag2[fa << 1] % m) % m; // 更新加法标记

    // 更新右子节点
    t[fa << 1 | 1] = (tag1[fa] * t[fa << 1 | 1] % m + (tag2[fa] * (r - mid)) % m) % m;
    tag1[fa << 1 | 1] = (tag1[fa << 1 | 1] * tag1[fa]) % m; // 更新乘法标记
    tag2[fa << 1 | 1] = (tag2[fa] + tag1[fa] * tag2[fa << 1 | 1] % m) % m; // 更新加法标记

    // 清空当前节点的标记
    tag1[fa] = 1; 
    tag2[fa] = 0;
}

// 建树函数
void build(LL l, LL r, LL fa) {
    if (l == r) { // 如果区间只有一个元素
        t[fa] = a[l] % m; // 直接赋值
        return;
    }
    LL mid = (l + r) >> 1; // 计算中间节点
    build(l, mid, fa << 1); // 递归构建左子树
    build(mid + 1, r, fa << 1 | 1); // 递归构建右子树
    push_up(fa); // 更新父节点
}

// 查询函数
LL query(LL ql, LL qr, LL l, LL r, LL fa) {
    LL ret = 0; // 初始化返回值
    if (ql <= l && qr >= r) { // 如果查询区间完全覆盖当前区间
        return t[fa] % m; // 返回当前节点的值
    }
    LL mid = (l + r) >> 1; // 计算中间节点
    push_down(l, r, fa); // 向下更新标记
    if (ql <= mid) // 如果查询区间在左子树
        ret = (ret + query(ql, qr, l, mid, fa << 1)) % m; // 查询左子树
    if (qr > mid) // 如果查询区间在右子树
        ret = (ret + query(ql, qr, mid + 1, r, fa << 1 | 1)) % m; // 查询右子树
    return ret % m; // 返回结果
}

// 更新函数
void update(LL ql, LL qr, LL l, LL r, LL fa, LL k) {
    if (ql <= l && qr >= r) { // 如果更新区间完全覆盖当前区间
        t[fa] = (t[fa] + (r - l + 1) * k) % m; // 更新当前节点的值
        tag2[fa] = (tag2[fa] + k) % m; // 更新加法标记
        return;
    }
    LL mid = (l + r) >> 1; // 计算中间节点
    push_down(l, r, fa); // 向下更新标记
    if (ql <= mid) // 如果更新区间在左子树
        update(ql, qr, l, mid, fa << 1, k); // 更新左子树
    if (qr > mid) // 如果更新区间在右子树
        update(ql, qr, mid + 1, r, fa << 1 | 1, k); // 更新右子树
    push_up(fa); // 更新父节点
}

// 乘法更新函数
void mulpr_update(LL ql, LL qr, LL l, LL r, LL fa, LL k) {
    if (ql <= l && qr >= r) { // 如果更新区间完全覆盖当前区间
        t[fa] = t[fa] * k % m; // 更新当前节点的值
        tag1[fa] = tag1[fa] * k % m; // 更新乘法标记
        tag2[fa] = tag2[fa] * k % m; // 更新加法标记
        return;
    }
    LL mid = (l + r) >> 1; // 计算中间节点
    push_down(l, r, fa); // 向下更新标记
    if (ql <= mid) // 如果更新区间在左子树
        mulpr_update(ql, qr, l, mid, fa << 1, k); // 更新左子树
    if (qr > mid) // 如果更新区间在右子树
        mulpr_update(ql, qr, mid + 1, r, fa << 1 | 1, k); // 更新右子树
    push_up(fa); // 更新父节点
}

// 主函数
int main() {
    cin >> n >> q >> m; // 输入数组大小 n, 查询次数 q, 模数 m
    for (int i = 0; i <= N * 4; i++) tag1[i] = 1; // 初始化乘法标记为 1
    for (int i = 1; i <= n; i++) cin >> a[i]; // 输入数组元素
    build(1, n, 1); // 构建线段树
    while (q--) { // 处理每个查询
        int op; cin >> op; // 输入操作类型
        if (op == 2) { // 加法更新操作
            LL x, y, k; cin >> x >> y >> k; // 输入区间 [x, y] 和加数 k
            update(x, y, 1, n, 1, k % m); // 执行加法更新
        }
        else if (op == 3) { // 查询操作
            LL x, y; cin >> x >> y; // 输入查询区间 [x, y]
            cout << query(x, y, 1, n, 1) % m << endl; // 输出查询结果
        }
        else if (op == 1) { // 乘法更新操作
            LL x, y, k; cin >> x >> y >> k; // 输入区间 [x, y] 和乘数 k
            mulpr_update(x, y, 1, n, 1, k); // 执行乘法更新
        }
    }
    return 0; // 程序结束
}

总结

本期关于线段树的讲解就到这里，有什么疑问或者有什么错误的地方欢迎大家一起交流学习，下期带来线段树的离散化，二分搜索等进阶内容

树+线段树+LCA的讲解
01-21
在线段树中，可以快速查询和更新节点信息，使得线段树非常适合动态规划的进阶应用。使用线段树时，节点可以存储区间信息，包括但不限于区间的最大值、最小值、总和、加减乘除等操作。 在解决实际问题时，动态规划的...
数据结构进阶：并查集、树状数组、线段树与高级算法应用
01-29
此外，探讨了一些特殊概念，如延迟标记、扫描线方法、动态开点线段树、树状数组套平衡树、以及可持久化线段树，这些高级结构有助于提升对复杂场景的处理能力。最后介绍了可持久化数据结构，允许访问特定时间点的数据...
线段树 从入门到进阶（超清晰，简单易懂）
热门推荐
繁凡さん的博客
02-12 10万+
目录第一部 概念引入第二部 简单（无pushdown）的线段树1、单点修改，区间查询2、区间修改，单点查询第三部 进阶线段树第四部 乘法（根号）线段树1、乘法线段树2、根号线段树模板题与代码：单点修改，区间查询：洛谷树状数组模板1区间修改，单点查询：洛谷树状数组模板2区间加法，洛谷线段树模板1区间乘法：洛谷线段树模板2区间根号，bzoj3211 线段树是什么？？线段树怎么写？？ 如果你在考提高组前...
线段树（从入门到进阶）
hahahahahaha5的博客
10-31 2731
首先，讲解线段树之前，应该了解到线段树应该是一种工具，可以将一些对于区间（或者线段）的修改、维护，从O(N)的时间复杂度变成O（logN）。 一.线段树概念引入 线段树是一种二叉树，也就是对于一个线段，我们会用一个二叉树来表示。比如说一个长度为5的线段，我们可以表示成这样： 这代表着如果你要表示线段的和，那么最上面的根节点权值就等于两个儿子节点的权值之和。 那么就可以得到：节点i的权值 = i节点的左儿子权值 + i节点的右儿子权值 二.简单线段树 三.区间+/-修改与区间查询 四.区间乘除修改与查询
线段树讲解
DJL新时代农民工DJL
08-04 214
此讲解参考于B站的一位高产的UP主,链接是:线段树 同时也推荐你们B站看一下左程云老师的线段树,应该是讲解的最清楚的一位大佬了,同时代码模板也是最标准的 线段树的结构: 单点更新,区间查询的线段树代码: #include<iostream> #define maxSize 1001 using namespace std; //单点更新，区间查询 void build_tree(int arr[], int tree[], int node, int start, int end) {
算法进阶--线段树（1）
2302_79458117的博客
10-06 1378
考录到线段树的篇幅过多，写五六十页的观感不佳，我把它分为多个章节，大家可以关注我看后续的更新。每章节我会把涉及的内容放在前面，给大家进行选择和查找。（章节我会用红体来表示,内容我会用蓝体表示）。 本章会介绍：一般线段树（主要是模板），主席树（可持久化的线段树），二逼平衡树（树套树，线段树套平衡树）。
【算法进阶详解】线段树应用
mkx2023275的博客
04-02 854
本文不讲解线段树的基础理论，而是讲解线段树的应用，如线段树优化 DP，扫描线。如有问题欢迎指出。
线段树进阶之延迟标记 （~详细整理）区间修改
pursuit的博客
08-08 2950
文章目录线段树进阶之延迟标记 （~详细整理）区间修改一、为什么需要添加延迟标记？二、区间修改具体实现 线段树进阶之延迟标记 （~详细整理）区间修改 一、为什么需要添加延迟标记？ 引入：我们如果要对某一区间的元素都进行更改，即是区间修改，不是单点修改。那么，对于没加延迟标记的线段树，我们要这样子进行修改： for(int i=l;i<=r;i++){ UpdateTree(i,value) } 这要进行r-l+1此单点修改来实现此区间修改操作，我们仔细想想，如果我们是这样进行的，单点修改的时间
线段树进阶之权值树
yangzijiangac的博客
11-16 370
抱怨： 真不应该直接去刚（主席树：可持久化线段树），从中午12点学晚上到快7点，才理解，这不是我能刚的动的，为什么？因为学主席树之前要先学权值线段树，如果不了解权值线段树，直接刚主席树，根本不知道在说个啥玩意,效率很低 现在我讲一下权值线段树： 给一串数 1，2，3，1，5，4 很明显这串数的值域是[1,5]，我们把值域二分为区间，求每一个区间有多少数，然后可以以通过这种方案来求：第k大或者...
线段树进阶（离散化与扫描线）
C_eeking的博客
04-13 1076
一些关于离散化和扫描线的简单讲解和练习题
线段树和线段数组
2301_80610560的博客
02-27 1361
因为如果对于 1 ∼ 4 这个区间，你把 1 ∼ 3 区间 + 1，相当于把节点 1 ∼ 2 2和 3标记，但是如果你查询 2 ∼ 4时，你会发现你加的时候，把没有标记的 2 节点和没有标记的 3 ∼ 4 节点加上去，结果当然是错的。到了 3 ∼ 4 区间，我们发现她并没有完全包含在答案区间 1 ∼ 3 里面，但发现她的左儿子 3 ∼ 3 区间和 1 ∼ 3 区间又交集，那么久走到 3 ∼ 3 区间。因为 1 ∼ 4 的和就是等于 1 ∼ 2 的和与 2 ∼ 3的和的和。
线段树乘法模板（从基础线段树扩展）
04-22
基础与进阶：从基础的线段树构建和操作开始，逐步深入到乘法操作的实现。 乘法操作：介绍了如何利用线段树高效地计算区间内元素的乘积，包括算法的设计和优化。 实用案例：通过实际编程示例，展示线段树乘法在...
std::print 和 std::println
janeqi1987的专栏
04-28 1058
std::print和是 C++23 新增的格式化输出函数，旨在替代传统的std::cout链式调用。它们基于实现，支持类型安全的格式化字符串，语法更简洁，性能更优15。直接输出到stdout（默认）或指定的流。自动在输出末尾添加换行符。支持与相同的格式化语法（如{}占位符）。
深入理解C语言中的整形提升与算术转换
qinyuz的博客
05-01 652
在C语言中，整形提升（Integer Promotion）是一个重要但容易被忽视的概念。它指的是在表达式中，任何小于。是无符号char，赋值-1会转换为255（0xFF）长度为标准操作数长度，使用标准长度可以提高运算效率。都是有符号char，值为-1（内存表示：0xFF）：符号扩展为0xFFFFFFFF（即-1）：零扩展为0x000000FF（即255））操作数在使用前都会被自动转换为普通整型。：确保不同大小的整型在运算时有一致的表现。有符号类型：高位补符号位。无符号类型：高位补0。是2字节，所以前两个。
STL之list容器
Laydya的博客
05-03 1366
1.list的底层是双向链表结构，双向链表中的每个元素在互不相关的独立结点中，在结点中通过指针指向前一个元素和后一个元素2.list是可以在常数范围内在任意位置的插入和删除的序列式容器，并且该容器可以前后双向迭代3.vector的优点：支持随机访问，间接的就支持了排序/二分查找/堆排序等缺点：1.头部和中部的插入效率低，需要挪动数据2.插入数据空间不够需要增容，增容需要开新空间，拷贝数据，释放旧空间list的优点：没有增容代价，且任意位置插入都是0（1）；
STL之vector容器
Laydya的博客
05-02 1221
1.vector是可变大小数组的容器2.像数组一样，采用连续的空间存储，也就意味着可以通过下标去访问，但它的大小可以动态改变3.每次的插入都要开空间吗？开空间就要意味着先开临时空间，然后在拷贝旧的到新的上面，在释放原来的，就时间而言，这是一个相对代价很高的任务；显然这是不行的，vector的分配策略：会分配一些而外的空间以适应可能的增长，例如我们平时说的以1.5或者2倍的方式增容，不同的库选择不同的策略权衡空间的使用和重新分配，以至于在插入一个元素时能在常数时间内插入；
游戏代码C
最新发布
2301_81771576的博客
05-03 453
以下将结合不同编程语言的特点及游戏开发中的实际应用，展示多种语言的游戏代码示例（以简单游戏为例，展示代码结构和逻辑差异）。3. Python/JavaScript/Lua：语法简洁，适合快速开发，代码量最少。Unity引擎集成度高，C#代码简洁但功能强大，适合快速开发跨平台游戏。1. C++：需手动管理资源（如字体加载），代码行数最多但性能最优。Lua语法极简，常用于游戏逻辑脚本（如《魔兽世界》插件）。1. C# + Unity（面向对象，适合跨平台开发）Python语法简洁，适合快速验证游戏逻辑。
第十一届蓝桥杯 2020 C/C++组 门牌制作
2301_80558092的博客
05-01 540
简单的数位切分问题，循环让i从1遍历到2020，每次定义临时变量temp存储i的值，每次通过temp%10取当前temp的最后一位，再通过temp/=10去掉当前temp的最后一位。把每次取的数位判断是否为2，把temp切到0就代表全部数位都切分出来了
【uom】 0 配置文件（Cargo.toml）
weixin_43219667的博客
04-29 514
这个配置文件表明 uom 是一个功能完善的单位计量库，支持多种数值类型和单位系统，可以在无标准库环境下使用，并提供了丰富的测试和示例。配置文档生成时启用的特性，包括各种数值类型支持（如 usize, u32, 大整数，有理数等）和 serde 支持。可选的 num-rational/num-bigint/num-complex: 分别支持有理数、大整数和复数。rust-version: 最低支持的 Rust 版本 1.65.0。支持各种数值类型（整数、大整数、有理数、复数等）mks: 米-千克-秒单位制。
评论 35
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值