线段树模板

最新推荐文章于 2023-01-27 00:50:09 发布
最新推荐文章于 2023-01-27 00:50:09 发布
阅读量359 收藏 1
点赞数 1
分类专栏： 板子 文章标签： 线段树 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DarthPPT/article/details/78320482
版权

其实从寒假就知道线段树这个东西了，但是嫌线段树写得长，一直用树状数组。
但最近发现线段树也很不错，于是就去做洛谷的两个线段树模板题（第一个模板曾经用树状数组A过）。
又因为去机房的时间较短较分散，于是就在自习课上对着线段树的那张图imagine线段树的原理并手动coding。
自己画的，好丑
对就是这张丑图
先说三个宏定义

#define ls (i << 1)
#define rs ((i << 1) | 1)
#define mid ((n[i].l + n[i].r) >> 1)

一定要加括号啊！！！
首先我们要建树
怎么看都要二分递归嘛~~~
递归到叶子（l == r）就把初始数组的相应位置的值丢到线段树里
然后往上回溯，顺便改区间值

inline void built(int i, int l, int r)//过去式防与关键字冲突
{
	n[i].l = l;
	n[i].r = r;
	if(l == r)
	{
		n[i].sm = read();
		return ;
	}
	int md = (l + r) >> 1;
	built(ls, l, md);
	built(rs, md + 1, r);
	ud(i);
	return ; 
}

如果输入顺序就是初始数组的顺序就不用存初始数组了，直接建树时读入（反正先递归左边的区间）
ud就是updata，改区间值，简单粗暴

inline void ud(int i)
{
	n[i].sm = (n[ls].sm + n[rs].sm) % P;
	return ;
}

然后就是单点修改
从根跑到叶子
跑到哪改到哪

inline void cp(int i, int k, int x)// change point
{
    if(n[i].l == k && k == n[i].r)
    {
        n[i].sm += x;
        return ;
    }
    if(k <= mid) cp(ls, k, x);
    else         cp(rs, k, x);
    return ;
}

区间查询也很无脑
如果我要查的区间完全盖住了当前区间，就返回当前的区间值。如果只有一部分重合，就摆 ~ 动 ~ （dx：摆动大法好）。和左边有重合就往左摆，和右边有重合就往右摆。注意mid是在左区间里。

inline long long gs(int i, int l, int r)
{
    if(l <= n[i].l && r >= n[i].r)
        return n[i].sm;
    long long ans = 0;
    if(l <= mid) ans += gs(ls, l, r);//区间端点完全传下去！！！
    if(r > mid)  ans += gs(rs, l, r);
    return ans;
}

区间修改就麻烦些了
如果我们仍然从根开始，跑到哪改到哪，直到每个叶子，其实复杂度比暴力还高
于是我们就想优化：Lazy！
如果当前区间完全要被修改，就只改这个区间而不去改它的儿子们（就是懒得改儿子），我们下次在见到这个区间时(不管是修改时还是查询时见到它），再去改它的F1两个儿子
也就是打Lazy标记和把Lazy标记传给儿子（Push Down）
Lazy标记的意义：当前区间已被修改而它的儿子没有改

inline void pda(int i, int ln, int rn)
{
	n[ls].lza = (n[ls].lza + n[i].lza) % P;
	n[rs].lza = (n[rs].lza + n[i].lza) % P;
	//父亲的lazy给儿子
	n[ls].sm = (n[ls].sm + n[i].lza * ln) % P;
	n[rs].sm = (n[rs].sm + n[i].lza * rn) % P;
	n[i].lza = 0;
	//它的儿子被改了，它自己就不用Lazy了
	return ;
}

inline void csa(int i, int l, int r, int x)
{
	if(n[i].l >= l && n[i].r <= r)
	{
		n[i].sm = (n[i].sm + x * (n[i].r - n[i].l + 1)) % P;
		//区间的sum都被加了x，所以要乘区间长度！！！
		n[i].lza = (n[i].lza + x) % P;
		//lazy标记就只记这个区间要+x，加多少取决于区间长，与lazy标记无关（果然有够lazy）
		return ;
	}
	if(n[i].lza) pda(i, mid - n[i].l + 1, n[i].r - mid);
	if(mid < r)  csa(rs, l, r, x);
	if(l <= mid) csa(ls, l, r, x);
	ud(i);
	return ;
}

以上内容完全可以用树状数组实现嘛QWQ
但如果加法和乘法一块改区间时树状数组就炸了
然而我线段树也炸了调了1h
我们用加法lazy和乘法lazy共同维护线段树

  • 如果我先加一个数再乘一个数，由乘法分配律知，相当于先乘一个数再加一个数
    所以传标记时先传乘再传加
  • 区间每个数都乘一个数，由乘法结合律知，相当于整个区间都乘一个数，即a1 * x + a2 * x … = x * (a1 + a2 + …)，即区间乘修改时不用乘区间长度
  • lazy乘的初值赋1！！！x * 0 = 0, x * 1 = x
  • 乘法会影响加法，因为先传了乘法。所以lazy乘改了lazy加也要相应的改

其实线段树最简单的地方就是可以复制粘贴，区间乘把区间加的复制过来一改就行

inline void pdm(int i, int ln, int rn)
{
	n[ls].lzm = (n[ls].lzm * n[i].lzm) % P;
	n[rs].lzm = (n[rs].lzm * n[i].lzm) % P;
	n[ls].lza = (n[ls].lza * n[i].lzm) % P;
	n[rs].lza = (n[rs].lza * n[i].lzm) % P;
	n[ls].sm = (n[ls].sm * n[i].lzm) % P;
	n[rs].sm = (n[rs].sm * n[i].lzm) % P;
	n[i].lzm = 1;
	return ;
}

inline void csm(int i, int l, int r, int x)
{
	if(n[i].l >= l && n[i].r <= r)
	{
		n[i].sm = (n[i].sm * x) % P;
		n[i].lzm = (n[i].lzm * x) % P;
		n[i].lza = (n[i].lza * x) % P;
		return ;
	}
	if(n[i].lzm != 1) pdm(i, mid - n[i].l + 1, n[i].r - mid);
	if(n[i].lza)      pda(i, mid - n[i].l + 1, n[i].r - mid);
	if(mid < r)  csm(rs, l, r, x);
	if(l <= mid) csm(ls, l, r, x);
	ud(i);
	return ;
}

长得好像有木有っﾟДﾟ)っ
最后就是完整的模板了
真的好长

/*********
push down multiply first
then push down add
*********/
#include <cstdio>
using namespace std;

inline long long read()
{
    long long n = 0,k = 1;
    char ch = getchar();
    while ((ch > '9' || ch < '0') && ch != '-')  ch = getchar();
    if(ch == '-') k = -1, ch = getchar();
    while (ch <= '9' && ch >= '0')
 	{
          n = n * 10 + ch - '0';
          ch = getchar();
    }
    return n * k;
}

inline void print(long long n)
{
    if(n < 0) {putchar('-'); n = -n;}
    if(n > 9) print(n / 10);
    putchar(n % 10 + '0');
    return ;
}

struct Node
{
	int l, r;
	long long sm, lza, lzm; //lazy_multiply
	Node()
	{
		lzm = 1;
	}
}n[500420];
long long N, M, P;

#define ls (i << 1)
#define rs ((i << 1) | 1)
#define mid ((n[i].l + n[i].r) >> 1)
inline void ud(int i)
{
	n[i].sm = (n[ls].sm + n[rs].sm) % P;
	return ;
}

inline void built(int i, int l, int r)
{
	n[i].l = l;
	n[i].r = r;
	if(l == r)
	{
		n[i].sm = read();
		return ;
	}
	int md = (l + r) >> 1;
	built(ls, l, md);
	built(rs, md + 1, r);
	ud(i);
	return ; 
}

inline void pda(int i, int ln, int rn)
{
	n[ls].lza = (n[ls].lza + n[i].lza) % P;
	n[rs].lza = (n[rs].lza + n[i].lza) % P;
	n[ls].sm = (n[ls].sm + n[i].lza * ln) % P;
	n[rs].sm = (n[rs].sm + n[i].lza * rn) % P;
	n[i].lza = 0;
	return ;
}

inline void pdm(int i, int ln, int rn)
{
	n[ls].lzm = (n[ls].lzm * n[i].lzm) % P;
	n[rs].lzm = (n[rs].lzm * n[i].lzm) % P;
	n[ls].lza = (n[ls].lza * n[i].lzm) % P;
	n[rs].lza = (n[rs].lza * n[i].lzm) % P;
	n[ls].sm = (n[ls].sm * n[i].lzm) % P;
	n[rs].sm = (n[rs].sm * n[i].lzm) % P;
	n[i].lzm = 1;
	return ;
}

inline long long as(int i, int l, int r)  // answer section
{
	if(n[i].l >= l && n[i].r <= r)
	    return n[i].sm;
	if(n[i].lzm != 1) pdm(i, mid - n[i].l + 1, n[i].r - mid);
	if(n[i].lza)      pda(i, mid - n[i].l + 1, n[i].r - mid);
	long long ans = 0;
	if(l <= mid) ans = (ans + as(ls, l, r)) % P;
	if(r > mid)  ans = (ans + as(rs, l, r)) % P;
	return ans;
}

inline void csa(int i, int l, int r, int x)
{
	if(n[i].l >= l && n[i].r <= r)
	{
		n[i].sm = (n[i].sm + x * (n[i].r - n[i].l + 1)) % P;
		n[i].lza = (n[i].lza + x) % P;
		return ;
	}
	if(n[i].lzm != 1) pdm(i, mid - n[i].l + 1, n[i].r - mid);
	if(n[i].lza)      pda(i, mid - n[i].l + 1, n[i].r - mid);
	if(mid < r)  csa(rs, l, r, x);
	if(l <= mid) csa(ls, l, r, x);
	ud(i);
	return ;
}

inline void csm(int i, int l, int r, int x)
{
	if(n[i].l >= l && n[i].r <= r)
	{
		n[i].sm = (n[i].sm * x) % P;
		n[i].lzm = (n[i].lzm * x) % P;
		n[i].lza = (n[i].lza * x) % P;
		return ;
	}
	if(n[i].lzm != 1) pdm(i, mid - n[i].l + 1, n[i].r - mid);
	if(n[i].lza)      pda(i, mid - n[i].l + 1, n[i].r - mid);
	if(mid < r)  csm(rs, l, r, x);
	if(l <= mid) csm(ls, l, r, x);
	ud(i);
	return ;
}

inline void prt()
{
	putchar('#');
	for(register int i = 1; i <= N; i++)
	    printf("%lld ", as(1, i, i));
	putchar(10);
	return ;
}

int main()
{
	N = read();
	M = read();
	P = read();
	built(1, 1, N);
	//prt();
	register int f, x, y, z;
	for(register int i = 1; i <= M; i++)
	{
		f = read();
		if(f == 1)
		{
			x = read();
			y = read();
			z = read();
			csm(1, x, y, z);
			//prt();
		}
		else if(f == 2)
		{
			x = read();
			y = read();
			z = read();
			csa(1, x, y, z);
			//prt();
		}
		else
		{
			x = read();
			y = read();
			print(as(1, x, y));
			putchar(10);
			//prt();
		}
	}
	return 0;
}

结合树剖食用更佳(～￣▽￣)～

DarthPPT
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线段树的四种模板
lhm的博客
07-20 3863
第一种模板只适合单点修改的题目，每次修改都传递到树的子节点。对于区间修改则不合适，同时，由于数组大小事先申明好，其点数也有上限。为了解决数据量的问题，这里提供了动态开点，解除了每个树的元素都占一个固定坑位的限制。但是仍然有限制，点数不可以随便加，有上限。和第一套模板相比，增加了区间修改的功能。但是点数仍然有上限，数据量顶多十万，再往上就不能适用了。点数无限制，需要的时候申请，但是效率会很低。...
自己写的线段树的模板_
09-20
c++的线段树模板
带懒惰标记的线段树模板
09-02
带懒惰标记的线段树模板
ZKW线段树模板类
08-06
在ZKW_Segment_Tree.cpp和ZKW_Segment_Tree.h两个文件中，我们可以找到线段树模板类的实现。cpp文件通常包含了函数的具体实现，而h文件则定义了类的接口。类的构造函数可能接收一个整型数组，用于初始化线段树，而...
线段树模板__模板
12-26
用c语言写的很好的线段树代码，供新手使用.
完整的线段树模板，基础模板
最新发布
04-22
本资源提供了一个完整的线段树基础模板，旨在帮助开发者快速掌握并应用线段树解决实际问题。 特点： 基础性：适合初学者和有一定基础的开发者，从零开始理解线段树的构建和运作原理。 完整性：包含了线段树的构建...
线段树模板 zoj1128
08-31
本资源是对线段树操作比较完整的操作，包括线段树的动态插入，动态删除和维护，可以查询区段的最大值，最小值，完成线段树的基本操作。
加法线段树模板.cpp
10-19
加法线段树模板
线段树（模板+例题——郭神）
02-17
线段树（模板+例题——郭神） 私用，随意拿！
线段树模板(史上最简单易懂的数据结构)
weixin_54442315的博客
04-19 2917
什么是线段树？ 线段树言下之意就是将线段分解为一颗树，并且这颗树是一颗二叉树，树上的每一个节点都具有某些性质。 线段树有什么用？ 线段树主要能够在O(logn)的时间复杂度上解决区间上的问题。 题目引入：AcWing243.一个简单的整数问题2 本题目就是很简单的线段树的板子题，可以用来当做模板来使用。 线段树的几个重要操作： 1.tree[]数组的建立： struct node{ int l;//表示左端点 int r;//表示右端点 int v;//表示区间内的...
线段树（原理，模板）
CegghnnoR的博客
01-27 752
算法——数据结构——线段树
线段树模板（Java）
Easenyang的博客
12-06 2434
  线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。它的主要优势是对于区间求和、区间求最大值、区间修改和单点修改的速度快，时间复杂度能达到O(logN)O(logN)O(logN)。   若以常规的方法在数组中进行区间求和等操作，时间复杂度会达到O(n)O(n)O(n)，若操作的次数量非常大，那么就很容易超时。线段树的优势就体现出来了   线段树的实现基于一维数组，用数组下标 2∗k+12 * k +12∗k+1 的元素代表左儿子，用下标 2∗k+
ACM线段树模板C++
04-05
ACM线段树模板C ```c #include using namespace std; const int N=1e5+5;//数组开大一点 int n,m; int a[N]; struct node{ int l,r;//左右端点 int sum,lazy;//区间和和懒标记 }t[N*4]; void up(int p){//向上...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值