线段树（连载中）

已于 2022-05-16 14:31:21 修改
阅读量92 收藏
点赞数 1
分类专栏： 算法和数据结构 线段树 文章标签： c++ 开发语言 后端
于 2021-10-20 21:56:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52093121/article/details/120876081
版权

维护区间加减和区间查询）：
模板一：

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int  n, m;
typedef long long ll;
ll ans[N << 2], a[N], tag[N << 2];

inline int ls(int x) {
	return x << 1;
}

inline int rs(int x) {
	return x << 1 | 1;
}

void pushdown(int p, int l, int r) {
	int mid = l + r >> 1;
	ans[ls(p)] += tag[p] * (mid - l + 1);
	ans[rs(p)] += tag[p] * (r - mid);
	tag[ls(p)] += tag[p];
	tag[rs(p)] += tag[p];
	tag[p] = 0;
}

void pushup(int p) {
	ans[p] = ans[ls(p)] + ans[rs(p)];
}

void build(int p, int l, int r) {
	tag[p] = 0;
	if (l == r) {
		ans[p] = a[l];
		return;
	}
	int mid = l + r >> 1;
	build(ls(p), l, mid);
	build(rs(p), mid + 1, r);
	pushup(p);
}


void update(int nl, int nr, int l, int r, int p, int k) {
	if (nl <= l && nr >= r) {
		tag[p] += k;
		ans[p] += k * (r - l + 1);
		return;
	}
	pushdown(p, l, r);
	int  mid = (l + r) >> 1;
	if (nl <= mid) update(nl, nr, l, mid, ls(p), k);
	if (nr > mid) update(nl, nr, mid + 1, r, rs(p), k);
	pushup(p);
}


ll query(int nl, int nr, int l, int r, int p) {
	ll  res = 0;
	if (nl <= l && nr >= r) return ans[p];
	int mid = (l + r) >> 1;
	pushdown(p, l, r);
	if (nl <= mid) res += query(nl, nr, l, mid, ls(p));
	if (nr > mid) res += query(nl, nr, mid + 1, r, rs(p));
	return res;
}

int main() {
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
	}
	build(1, 1, n);
	while (m--) {
		int x, y, z, k;
		scanf("%d", &z);
		if (z == 1) {
			scanf("%d%d%d", &x, &y, &k);
			update(x, y, 1, n, 1, k);
		} else {
			scanf("%d%d", &x, &y);
			ll res = query(x, y, 1, n, 1);
			printf("%lld\n", res);
		}
	}
}

线段树模板二：

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int tag[N * 4];

struct node {
	int l;
	int r;
	long long  w;
} tr[N * 4];

int n, m;
int a[N];
int x, y, k;
int s;


void pushup(int p) {
	tr[p].w = tr[p << 1].w + tr[p << 1 | 1].w;
}

void pushdown(int p) {
	int mid = tr[p].r + tr[p].l >> 1;
	tr[p << 1].w += tag[p] * (mid - tr[p].l + 1);
	tr[p << 1 | 1].w += tag[p] * ( tr[p].r - mid);
	tag[p << 1] += tag[p];
	tag[p << 1 | 1] += tag[p];
	tag[p] = 0;
}


void build(int p, int l, int r) {
	tr[p] = {l, r, 0};
	if (l == r) {
		tr[p].w = a[l];
		return ;
	}
	int mid = tr[p].l + tr[p].r >> 1;
	build(p * 2, l, mid);
	build(p * 2 + 1, mid + 1, r);
	pushup(p);
	return ;
}


void  modify(int p, int x, int y, int k) {
	if (tr[p].l >= x && tr[p].r <= y) {
		tr[p].w += k * ( (tr[p].r - tr[p].l + 1));
		tag[p] += k;
		return;
	}
	pushdown(p);
	int mid = tr[p].r + tr[p].l >> 1;
	if (x <= mid) modify(p << 1, x, y, k);
	if (y > mid)  modify(p << 1 | 1, x, y, k);
	pushup(p);
}

long long  query(int p, int x, int y) {
	if (tr[p].l >= x && tr[p].r <= y) {

		return tr[p].w;
	}
	pushdown(p);
	int mid = tr[p].l + tr[p].r >> 1;
	long long t = 0;
	if (x <= mid) t += query(p << 1, x, y);
	if (y > mid)  t += query(p << 1 | 1, x, y);
	return t;
}


int main() {
	cin >> n >> m;
	for (int i = 1; i <= n; i++) cin >> a[i];
	build(1, 1, n);
	for (int i = 1; i <= m; i++) {
		cin >> s;
		if (s == 1) {
			cin >> x >> y >> k;
			modify(1, x, y, k);
		} else {
			cin >> x >> y;
			cout << query(1, x, y) << endl;
		}
	}
}

2.线段树模板（同时支持区间加法和乘法，以及求区间和）：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<queue>
#include<map>
#include<unordered_map>
#include<set>
#include<stack>
#include<utility>
#include<cstdlib>
#include<cmath>
using namespace std;
const int N = 1e5 + 10;
typedef long long ll;
struct node {
	ll l;
	ll  r;
	ll add;
	ll mul;
	ll w;
} tr[N * 4];
ll n, m, p;
ll a[N];

inline void pushup(ll u) {
	tr[u].w = (tr[u << 1].w + tr[u << 1 | 1].w) % p;
}

inline void pushdown(ll u) {
	tr[u << 1].w = (tr[u].mul * tr[u << 1].w + tr[u].add * (tr[u << 1].r - tr[u << 1].l + 1)) % p;
	tr[u << 1 | 1].w = (tr[u].mul * tr[u << 1 | 1].w + tr[u].add * (tr[u << 1 | 1].r - tr[u << 1 | 1].l + 1)) % p;


	tr[u << 1].mul = (tr[u].mul * tr[u << 1].mul) % p;
	tr[u << 1 | 1].mul = (tr[u].mul * tr[u << 1 | 1].mul) % p;


	tr[u << 1].add = (tr[u << 1].add * tr[u].mul + tr[u].add) % p;
	tr[u << 1 | 1].add = (tr[u << 1 | 1].add * tr[u].mul + tr[u].add) % p;
	tr[u].mul = 1;
	tr[u].add = 0;
	return;
}


void build(ll u, ll l, ll r) {

	tr[u] = { l, r, 0, 1, 0 };
	if (l == r) {
		tr[u].w = a[l] % p;
		return;
	}
	int mid = l + r >> 1;
	build(u << 1, l, mid);
	build(u << 1 | 1, mid + 1, r);
	pushup(u);
	tr[u].w %= p;
	return;
}

void up1(ll u, ll l, ll r, ll k) {
	if (tr[u].l >= l && tr[u].r <= r) {
		tr[u].w = (tr[u].w * k) % p;
		tr[u].mul = (tr[u].mul * k) % p;
		tr[u].add = (tr[u].add * k) % p;
		return;
	}
	pushdown(u);
	pushup(u);
	int mid = tr[u].l + tr[u].r >> 1;
	if (l <= mid) up1(u << 1, l, r, k);
	if (r > mid) up1(u << 1 | 1, l, r, k);
	pushup(u);
}

void up2(ll u, ll l, ll r, ll k) {
	if (tr[u].l >= l && r >= tr[u].r) {
		tr[u].add = (tr[u].add + k) % p;
		tr[u].w = (tr[u].w + k * (tr[u].r - tr[u].l + 1)) % p;
		return;
	}
	pushdown(u);
	pushup(u);
	int mid = tr[u].l + tr[u].r >> 1;
	if (l <= mid) up2(u << 1, l, r, k);
	if (r > mid)  up2(u << 1 | 1, l, r, k);
	pushup(u);
	return;
}


ll query(ll u, ll l, ll r, ll p) {
	if (tr[u].l >= l && tr[u].r <= r) {
		return tr[u].w % p;
	}
	pushdown(u);
	ll ans = 0;
	int mid = tr[u].l + tr[u].r >> 1;
	if (l <= mid) ans = (query(u << 1, l, r, p)) % p;
	if (r > mid) ans = (ans + query(u << 1 | 1, l, r, p)) % p;
	return ans % p;
}



int main() {
	scanf("%lld%lld%lld", &n, &m, &p);
	for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
	build(1, 1, n);
	for (int i = 1; i <= m; i++) {
		long long x, y, k;
		ll op;
		scanf("%lld", &op);
		if (op == 1) {
			scanf("%lld%lld%lld", &x, &y, &k);
			up1(1, x, y, k);
		}
		else if (op == 2) {
			scanf("%lld%lld%lld", &x, &y, &k);
			up2(1, x, y, k);
		}
		else {
			scanf("%lld%lld", &x, &y);
			printf("%lld\n", query(1, x, y, p));
		}
	}
	return 0;
}

cf例题，区间改变和单点改变

/*********************************************************************
    程序名:
    版权:
    作者:	Joecai
    日期: 2022-05-16 13:57
    说明:
*********************************************************************/

#include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
# define rep(i,be,en) for(int i=be;i<=en;i++)
# define pre(i,be,en) for(int i=be;i>=en;i--)
#define ll long long
#define endl "\n"
#define LOCAL
#define pb push_back
#define int	long long
typedef pair<ll, ll> PII;
#define eb emplace_back
#define sp(i) setprecision(i)
const int N = 2e5 + 10, INF = 0x3f3f3f3f;


int n, q;

struct node
{
	int l;
	int r;
	int sum;
	int tag;
} tr[N << 2];
int a[N];

void pushup(int u)
{
	tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}


void pushdown(int u)
{
	tr[u << 1].sum = (tr[u << 1].r - tr[u << 1].l + 1) * tr[u].tag;
	tr[u << 1 | 1].sum = (tr[u << 1 | 1].r - tr[u << 1 | 1].l + 1) * tr[u].tag;
	tr[u << 1].tag = tr[u].tag;
	tr[u << 1 | 1].tag = tr[u].tag;
	tr[u].tag = 0;
}


void build(int u, int l, int r)
{
	tr[u] = {l, r};
	if (l == r)
		{
			tr[u].sum = a[l];
			return;
		}
	int mid = l + r >> 1;
	build(u << 1, l, mid);
	build(u << 1 | 1, mid + 1, r);
	pushup(u);
}


void update(int u, int l, int r, int s)
{
	if (tr[u].r <= r && tr[u].l >= l)
		{
			tr[u].sum = (tr[u].r - tr[u].l + 1) * s;
			tr[u].tag = s;
			return;
		}
	if (tr[u].tag)
		pushdown(u);
	int mid = tr[u].l + tr[u].r >> 1;
	if (l <= mid)
		update(u << 1, l, r, s);
	if (r > mid)
		update(u << 1 | 1, l, r, s);
	pushup(u);

}

int query(int u, int l, int r)
{
	if (tr[u].r <= r && tr[u].l >= l)
		{
			return tr[u].sum;
		}
	if (tr[u].tag)
		pushdown(u);
	int sum = 0;
	int mid = tr[u].r + tr[u].l >> 1;
	if (l <= mid)
		sum += query(u << 1, l, r);
	if (r > mid)
		sum += query(u << 1 | 1, l, r);

	return sum;
}


void solve()
{
	cin >> n >> q;
	for (int i = 1; i <= n; i++)
		{
			cin >> a[i];
		}
	build(1, 1, n);

	for (int i = 1; i <= q; i++)
		{
			int op, x, y;
			cin >> op;
			if (op == 1)
				{
					cin >> x >> y;
					update(1, x, x, y);
					cout << query(1, 1, n) << endl;
				}
			else
				{
					cin >> y;

					update(1, 1, n, y);
					cout << query(1, 1, n) << endl;

				}
		}

}




signed main()
{
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);
	//#ifdef LOCAL
	//freopen("data.in.txt","r",stdin);
	//freopen("data.out.txt","w",stdout);
	//#endif
	int __ = 1;
	//cin>>__;
	while (__--)
		{
			solve();
		}
	return 0;
}
/*
5 5
1 2 3 4 5
1 1 5
2 10
1 5 11
1 4 1
2 1


19
50
51
42
5

*/
蔡珏
关注
专栏目录
线段树建树
12-14
线段树是一种二叉树，也就是说，每个线段都可以用一二叉树表示 比如一个长度为4的线段可以如此表示： ——————————————-4 1————-2————-3————4 1 2 3 4 如果你要表示线段上的和，最上面的根...
线段树模板
02-03
手打了一份线段树代码，...使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度为2N，实际应用时一般还要开4N的数组以免越界，因此有时需要离散化让空间压缩。
线段树
奋斗de穷小子
08-10 694
线段树 目录   零、前言 一、引例       1、区间最值       2、区间求和 二、线段树的基本概念      1、二叉搜索树      2、数据域      3、指针表示      4、数组表示 三、线段树的基本操作       1、构造       2、更新       3、询问 四、线段树的经典案例    
转载-夜深人静写算法（七） - 线段树
weixin_30808575的博客
10-16 153
转载-夜深人静写算法（七） - 线段树 转载自http://www.cppblog.com/menjitianya/archive/2016/02/25/212891.html 目录 零、前言 一、引例 ...
【BZOJ—2957楼房重建】【连载：请在T台上微笑】
22ssm的博客
07-05 542
长久没有发博文了。。。对对对， 所以最近就趁着暑假多发发吧 颓废是革命的本钱： 推荐一个我喜欢的新连载漫画吧【请在T台上微笑】 BZOJ 2957 【楼房重建】Description　小A的楼房外有一大片施工工地，工地上有N栋待建的楼房。每天，这片工地上的房子拆了又建、建了又拆。他经常无聊地看着窗外发呆，数自己能够看到多少栋房子。 　　为了简化问题，我们考虑这些事件发生
【AC军团周报（第二周）第二篇】线段树从入门到入土【2】
weixin_30468137的博客
12-02 80
本文章连载AC军团周报 -> 线段树 ： 从入门到入土【2】 前言： 第二期了，我们要把上一期留下的锅补一下。 这一期的内容主要是懒标记，处理区间修改的问题。 我们最后再分析一下线段树时间复杂度 一、线段树入门（续） 我们上一期学习了线段树的入门操作，主要是进行建树，区间查询，单点修改。我们来仔细回想一下吧。 ……………………回想时间…………………… 如果你回想完了，就再思考一下上一节留下的...
【AC军团周报（第一周）第一篇】线段树从入门到入土【1】
weixin_30344795的博客
12-02 87
本文章连载AC军团周报 -> 线段树 ： 从入门到入土【1】 前言： 正如你所见，我这系列文章可以从入门来看，想入土的（伪）也可以进行观看（逃 本系列的文章将详讲线段树的思想，代码实现，并以一部分系列习题（这会不告诉你是哪一套，怕你直接关闭界面）来更深刻的了解线段树。 一、线段树入门 很多人对于线段树的印象就是：代码长，de不出bug，容易写错，还是个高级数据结构吓人诶。 但如果真的讲起，就...
【AC军团周报（第三周）第三篇】线段树从入门到入土【3】
weixin_30371875的博客
12-02 97
本文章连载AC军团周报 -> 线段树 ： 从入门到入土【3】 前言 这期我们就万能的线段树，讲一讲线段树的奇葩用法。 你可能不知道这些线段树用法：线段树维护区间最大子段和、线段树优化Dijkstra（大雾）…… 三、线段树部分用法 1.线段树维护区间最大子段和 我们已经学过线段树，再仔细的回想下吧！ …………………………………………日常回想时间……………………………………………… 我们应该还...
树线段hdu 1166 敌兵布阵(线段树)
weixin_30895603的博客
05-31 81
最近研究树线段，稍微总结一下，以后继续补充： 题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1166 题目大意: 给出初始化的区间值，然后有三种讯问 Query a b 讯问区间[a,b]值的总和 Ad...
【AC军团周报（第四周）第一篇】线段树从入门到入土【4】（未完成）
weixin_30564901的博客
12-02 89
本文章连载AC军团周报 -> 线段树 ： 从入门到入土【4】 前言 从前有一位远古神犇，他汇集各大数据结构之精华，经过艰苦卓绝的研究，终于炼制成了一种新的，更简洁的，更快的线段树——zkw线段树 （大雾） 四、zkw线段树基础 我们已经学过了线段树的基础了，相信大家已经熟练掌握线段树大概的样子了。 线段树什么样子，，，二叉树？ 那二叉树我们怎么进行查找修改？是不是用的递归？ 突然，有一天，你...
蒟蒻的省选复习（不如说是noip普及组复习）————连载中
weixin_30568715的博客
04-16 156
1.筛法 1 var 2 n,m,i,x,tot,j :longint; 3 prime :array[0..10000050] of boolean; 4 p ...
线段树的一种实现
12-25
在提供的压缩包文件“线段树”中，可能包含了实现线段树的数据结构、相关的测试用例和详细的注释，帮助用户理解和使用。对于想要深入理解线段树或者需要在实际项目中应用线段树的人来说，这个资源将会非常有价值。...
权值线段树和主席树入门
09-25
权值线段树和主席树入门PPT，权值线段树，顾名思义就是记录权值的线段树，普通的线段树直接以坐标为l，r建树，而权值线段树是以大小来建树，树上寸的信息是该权值的数量，而通过建树时二分从小到大的性质，可以用这...
Camp4-L0：Linux 前置基础
fangsfdavid的博客
10-29 842
书生浦语大模型实战营第四期：Linux前置基础
第八天: C语言深度探索：指针与函数的奥秘
最新发布
qq_57484399的博客
10-31 575
通过今天的学习，我们了解了字符指针和字符串在C语言中的处理方式。希望大家能够掌握这些基本概念，并在实际编程中灵活运用。好了，今天的课就到这里。希望大家能够掌握指针与函数参数的关系，以及如何通过指针来改变外部变量的值。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。希望大家能够掌握数组名作为函数参数的用法，以及如何通过函数来处理数组。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。
C++：继承与多态（面试题篇）
Jdxxwu的博客
10-26 1307
本文将讲解总结继承和多态的常见面试题~🫡🫡🫡
第20课-C++【二叉搜索树】
2401_83603768的博客
10-25 1045
二叉搜索树（Binary search tree）是一种特殊的二叉树，它的每个节点的左子树中的所有节点值都小于该节点值，而右子树中的所有节点值都大于该节点值。
C语言中的数组并非指针：深入理解数组和指针的区别
极客代码
10-29 555
在C语言中，数组和指针是两个非常重要的概念，它们在很多方面有着紧密的联系，但也存在显著的区别。尽管数组名有时可以像指针那样使用，但它们本质上并不是一回事。理解这些差异对于编写正确和高效的代码至关重要。本文将深入探讨数组和指针的区别，并提供一些示例代码。1. 数组与指针的基础概念数组：数组是一系列相同类型数据的集合，它们在内存中连续存储。数组名本身是一个常量，指向数组的起始位置。指针：指针是一个变量，其值为另一个变量的地址。指针可以指向数组中的任何一个元素。2. 数组与指针的相似之处数组名作为指针。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值