[模板][线段树]

最新推荐文章于 2021-05-20 21:22:32 发布
最新推荐文章于 2021-05-20 21:22:32 发布
阅读量170 收藏
点赞数
分类专栏： 模板 树(Tree)
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zeolim/article/details/81585577
版权

 1.区间加和求极值lazy

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
typedef long long ll;
const ll MOD = 1e9 + 7;
const int MX = 1e5 + 7;

int arr[MAXN] = {0};

struct sgt
{
	struct node{int l, r, mx, add;}t[MAXN << 2];
	
	void pushup(int now)
	{
		t[now].mx = max(t[now * 2].mx, t[now * 2 + 1].mx);
	}
	
	void build(int now, int l, int r)
	{
		t[now].l = l, t[now].r = r;
		if(l == r) {t[now].mx = arr[l]; return ;}
		int mid = (l + r) / 2;
		build(now * 2, l, mid);
		build(now * 2 + 1, mid + 1, r);
		pushup(now);
	}
	
	void push(int now)
	{
		if(t[now].add)
		{
			int val = t[now].add;
			t[now * 2].mx += val;
			t[now * 2 + 1].mx += val;
			t[now * 2].add += val;
			t[now * 2 + 1].add += val;
			t[now].add = 0;
		}
	}
	void add(int now, int l, int r, int val)
	{
		if(l <= t[now].l && r >= t[now].r)
		{
			t[now].add += val;
			t[now].mx += val;
			return ;
		}
		push(now);
		int mid = (t[now].l + t[now].r) / 2;
		if(l <= mid) add(now * 2, l, r, val);
		if(r > mid) add(now * 2 + 1, l, r, val);
		t[now].mx = max(t[now * 2].mx, t[now * 2 + 1].mx);
	}
	int query(int now, int l, int r)
	{
		if(l <= t[now].l && r >= t[now].r) return t[now].mx;
		push(now);
		int ret = 0, mid = (t[now].l + t[now].r) / 2;
		if(l <= mid) ret = max(ret, query(now * 2, l, r));
		if(r > mid) ret = max(ret, query(now * 2 + 1, l, r));
		return ret;
	}
};

int main()
{ 
	//ios::sync_with_stdio(0);
	//cin.tie(0); cout.tie(0);
	//freopen("1.txt", "r", stdin);
	
	int n, m;
	
	cin >> n >> m;
	
	for(int i = 1; i <= n; ++i)
		cin >> arr[i];
		
	sgt T;
	
	T.build(1, 1, n);
		
	char q;
	int x, y, z;
	while(m--)
	{
		cin >> q;
		if(q == 'Q')
		{
			cin >> x >> y;
			cout << T.query(1, x, y) << '\n';
		}
		else
		{
			cin >> x >> y >> z;
			T.add(1, x, y, z);
		}
	}

    return 0;
}

struct sgt
{
	struct node{int l, r, mx, mi, add;}t[MAXN << 2];
	
	sgt()	{ memset(t, 0, sizeof(node)); }
	void pushup(int now)
	{
		t[now].mx = max(t[now * 2].mx, t[now * 2 + 1].mx);
		t[now].mi = min(t[now * 2].mi, t[now * 2 + 1].mi);
	}
	
	void build(int now, int l, int r)
	{
		t[now].l = l, t[now].r = r;
		if(l == r) {t[now].mx = t[now].mi = 0; return ;}
		int mid = (l + r) / 2;
		build(now * 2, l, mid);
		build(now * 2 + 1, mid + 1, r);
		pushup(now);
	}
	
	void push(int now)
	{
		if(t[now].add)
		{
			int val = t[now].add;
			t[now * 2].mx += val;
			t[now * 2 + 1].mx += val;
			t[now * 2].mi += val;
			t[now * 2 + 1].mi += val;
			t[now * 2].add += val;
			t[now * 2 + 1].add += val;
			t[now].add = 0;
		}
	}
	
	void add(int now, int l, int r, int val)
	{
		if(l <= t[now].l && r >= t[now].r)
		{
			t[now].add += val;
			t[now].mx += val;
			t[now].mi += val;
			return ;
		}
		push(now);
		int mid = (t[now].l + t[now].r) / 2;
		if(l <= mid) add(now * 2, l, r, val);
		if(r > mid) add(now * 2 + 1, l, r, val);
		t[now].mx = max(t[now * 2].mx, t[now * 2 + 1].mx);
		t[now].mi = min(t[now * 2].mi, t[now * 2 + 1].mi);
	}
	
	int query(int now, int l, int r)
	{
		if(l <= t[now].l && r >= t[now].r) return t[now].mx;
		push(now);
		int ret = -INF, mid = (t[now].l + t[now].r) / 2;
		if(l <= mid) ret = max(ret, query(now * 2, l, r));
		if(r > mid) ret = max(ret, query(now * 2 + 1, l, r));
		return ret;
	}
	
	int querymi(int now, int l, int r)
	{
		if(l <= t[now].l && r >= t[now].r) return t[now].mi;
		push(now);
		int ret = 0x3f3f3f3f, mid = (t[now].l + t[now].r) / 2;
		if(l <= mid) ret = min(ret, querymi(now * 2, l, r));
		if(r > mid) ret = min(ret, querymi(now * 2 + 1, l, r));
		return ret;
	}
}t;

 2.区间加和求和lazy

#pragma GCC optimize(2)
#include <cstdio>
#include <iostream>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <string>
#include <cstring>
#include <algorithm>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <ctime>
#include <vector>
#include <fstream>
#include <list>
#include <iomanip>
#include <numeric>
using namespace std;
typedef long long ll;
const int MAXN = 1e6 + 10;

ll arr[MAXN] = {0};
ll tree[MAXN * 4 + 10] = {0};
ll b[MAXN] = {0};

void init(int now, int l, int r)
{
	if(l == r) { tree[now] = arr[l]; return ; }
	int mid = l + (r - l) / 2;
	init(now * 2, l, mid);
	init(now * 2 + 1, mid + 1, r);
	tree[now] = tree[now * 2] + tree[now * 2 + 1];
}

void pushdown(int now, int l , int r)
{
	if(b[now])
	{
		b[now * 2] += b[now];
		b[now * 2 + 1] += b[now];
		int mid = l + (r - l) / 2;
		tree[now * 2] += b[now] * (mid - l + 1);
		tree[now * 2 + 1] += b[now] * (r - mid);
		b[now] = 0; 
	}
}

ll find(int now, int l, int r, int x, int y)
{
	if(x > r || y < l) return 0;
	if(x <= l && y >= r) return tree[now]; 
	pushdown(now, l, r);
	int mid = l + (r - l) / 2;
	ll ans = 0;
	ans += find(now * 2, l, mid, x, y);
	ans += find(now * 2 + 1, mid + 1, r, x, y);
	return ans;
}



void update(int now, int l, int r, int x, int y, ll add)
{	
	if(l > y || x > r) return ;
		
	if(l >= x && r <= y) b[now] += add, tree[now] += add * (r - l + 1); return ;
	pushdown(now, l, r);
	int mid = l + (r - l) / 2;	
	update(now * 2, l, mid, x, y, add);
	update(now * 2 + 1, mid + 1, r, x , y, add);
	tree[now] = tree[now * 2] + tree[now * 2 + 1];
}

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);     cout.tie(0);

    ll len, oprt;
    cin>>len>>oprt;
    for(int i = 1; i <= len; i++) cin>>arr[i];
    init(1, 1, len);
	int x, y;
	while(oprt--)
	{
		int mode, x, y, k;
		cin>>mode;
		if(mode == 1)
		{
			cin>>x>>y>>k;
			update(1, 1, len, x, y, k);
		}
		else
		{
			cin>>x>>y;
			cout<<find(1, 1, len, x, y)<<endl;
		}
	}
    return 0;
}

2. 区间乘

//#pragma GCC optimize(2)
#include <cstdio>
#include <iostream>
#include <cmath>
#include <cctype>
#include <string>
#include <cstring>
#include <algorithm>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <ctime>
#include <vector>
#include <fstream>
#include <list>
#include <iomanip>
#include <numeric>
using namespace std;
typedef long long ll;
  
const int MAXN = 4e4 + 10;
 
ll arr[MAXN];
 
struct node             //节点
{
    ll v;
    ll mul, add;     //lazatag
}tree[MAXN];

void init(int now, int fst, int lst) //建树
{
    tree[now].mul = 1, tree[now].add = 0;
    if(fst == lst) { tree[now].v = arr[fst]; return ; }
    int mid = (fst + lst) / 2;
    init(now * 2, fst, mid);
    init(now * 2 + 1, mid + 1, lst);   
    tree[now].v = tree[now * 2].v + tree[now * 2 + 1].v;
}

void pushdown(int now, int fst, int lst) //lazypush
{
    int mid = (fst + lst) / 2;
    tree[now * 2].v = (tree[now * 2].v * tree[now].mul + tree[now].add * (mid - fst + 1));
    tree[now * 2 + 1].v = (tree[now * 2 + 1].v * tree[now].mul + tree[now].add * (lst - mid));
    tree[now * 2].mul = (tree[now * 2].mul * tree[now].mul);
    tree[now * 2 + 1].mul = (tree[now * 2 + 1].mul * tree[now].mul);
    tree[now * 2].add = (tree[now * 2].add * tree[now].mul + tree[now].add);
    tree[now * 2 + 1].add = (tree[now * 2 + 1].add * tree[now].mul + tree[now].add);
    tree[now].mul = 1;
    tree[now].add = 0;
}

void updatemul(int now, int x, int y, int fst, int lst, long long k)
{

    if(lst < x || y < fst)
        return ;
    if(fst <= x && y <= lst)
    {
        tree[now].v = (tree[now].v * k);
        tree[now].mul = (tree[now].mul * k);
        tree[now].add = (tree[now].add * k);
    }
    else
    {
        pushdown(now, x, y);
        int mid = (x + y) / 2;
        updatemul(now * 2, x, mid, fst, lst, k);
        updatemul(now * 2 + 1, mid + 1, y, fst, lst, k);
        tree[now].v = (tree[now * 2].v + tree[now * 2 + 1].v);
    }
}

void updatesum(int now, int x, int y, int l, int r, long long k)
{
     
    if(r < x || y < l)
        return ;
    if(l <= x && y <= r)
    {
        tree[now].add = (tree[now].add + k);
        tree[now].v = (tree[now].v + k * (y-x+1));
    }
    else
    {
        pushdown(now, x, y);
        int mid = (x + y) / 2;
        updatesum(now * 2, x, mid, l, r, k);
        updatesum(now * 2 + 1, mid + 1, y, l, r, k);
        tree[now].v = (tree[now * 2].v + tree[now * 2 + 1].v);
    }
}

long long query(int now, int x, int y, int fst, int lst) //询问所有数和
{
    if(lst < x || y < fst)
        return 0;
    if(fst <= x && y <= lst)
    {
        return tree[now].v;
    }
    pushdown(now, x, y);
    int mid = (x + y) / 2;
    return (query(now * 2, x, mid, fst, lst) + query(now * 2 + 1, mid + 1, y, fst, lst));
}
 
long long query1(int now, int x, int y, int l, int r) //询问所有数平方和
{
    if(r < x || y < l)
        return 0;
    if(x == y) return tree[now].v * tree[now].v;
    pushdown(now, x, y);
    int m = (x + y) / 2;
    return (query1(now * 2, x, m, l, r) + query1(now * 2 + 1, m + 1, y, l, r));
}
 
int main()
{
    int n, m;
 
    scanf("%d%d", &n, &m);
 
    for(int i = 1; i <= n; i++)
        scanf("%lld", &arr[i]);
 
    init(1, 1, n);
 
    while(m--)
    {
        int mode;
 
        scanf("%d", &mode);
         
        int x, y;
        long long k;
         
        if(mode == 3)
        {
            scanf("%d%d%lld", &x, &y, &k);
            updatemul(1, 1, n, x, y, k);
        }
        else if(mode == 4)
        {
            scanf("%d%d%lld", &x, &y, &k);
            updatesum(1, 1, n, x, y, k);
        }
        else if(mode == 1)
        {
            scanf("%d%d", &x, &y);
            printf("%lld\n", query(1, 1, n, x, y));
        }
        else if(mode == 2)
        {
            cin>>x>>y;
            printf("%lld\n", query1(1, 1, n, x, y));
        }
    }

    return 0;
}

 

Zeolim
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线段树模板
02-03
手打了一份线段树代码，用于c++编程， 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 使用线段树可以快速的查找某一个节点在若干条线段中出现的...
线段树【模板】及解释
CZ_WangJunpeng的博客
10-01 1108
众所周知，线段树是一种十分狗好用的算法。 线段树是通过一颗
简单线段树模板
Marcus-Bao的个人主页
09-19 1354
例如:   给你任意几个数,给定N个区间,让你求这个区间的和;简单线段树的运用,帮助我更好的理解线段树,             //线段树基本 #include #define MAXN 100100 #define MINN 10000100 int  num[MAXN],t[MINN]; void build(int L,int R,int d) {      if(L==R)
线段树模板整理
歪歪T的拿金之路
04-10 7804
综述线段树的原理：将[1,n]分解成若干特定的子区间(数量不超过4*n),然后，将每个区间[L,R]都分解为少量特定的子区间，通过对这些少量子区间的修改或者统计，来实现快速对[L,R]的修改或者统计。 作用：对编号连续的一些点的区间信息进行修改或者统计操作 主要操作：区间查询、点更新、区间更新 时间复杂度：修改和统计的复杂度都是O(log(N))由原理可以看出线段树维护的信息必须满足区间加法
线段树详解
orz
05-20 9794
1. 什么是线段树 顾名思义 ， 线段树是一棵二叉树 ， 但不同的是这棵树的结点储存的值是一个数列中 [l,r][l,r][l,r] 的某个需要的值 （例如，求和，求最大值，求最小值） 这是一棵典型的线段树 ，其性质是 ： 若其中一子节点编号为 aaa ， 则该节点左儿子编号为 2a2a2a ， 其右儿子编号为 2a+12a+12a+1 2. 线段树的用处 线段树的用处就是，对编号连续的一些点进行修改或者统计操作，修改和统计的复杂度都是 O(log2n)O(log_2 n)O(log2​n). 3.
自己写的线段树的模板_
09-20
c++的线段树模板
线段树模版（比较基本的线段树以及例题模板）
11-01
关于一些典型的线段树的例题，大家可以看一看，给一个评价，这些内容，后续我也会在博客上慢慢更新。希望大家多多的支持作者，谢谢！ 这篇内容主要包含了一些我写的线段树的代码，可以帮助大家更好的理解线段树建树...
线段树学习笔记（个人整理模板）
12-25
个人线段树学习整理
[杂谈]关于GCC128位大整数的使用
Zeolim的博客
03-11 2454
GCC官方提供了 int128 (有符号128位整数) uint128 (无符号128位整数) 两种变量类型, 但是windows环境下大多编译器无法编译 OnlineJudge 主要是linux环境 所以平时用ubuntu / linux环境的在线编译器 刷题还是比较贴近竞赛环境的 GCC库自带 IO 没有提供对 int128环境的支持 所以需要自己编译读入读出 模板: void...
[数据结构] 对顶堆求中位数
Zeolim的博客
03-19 823
中位数求法比较多 离线的我不会 比较容易实现的就是 在线的对顶堆 对顶堆的定义： 小顶堆存 大于小顶堆堆顶 的 所有元素 大顶堆存 小于大顶堆堆顶 的 所有元素 那么 小顶堆和大顶堆堆顶 就是整个 当前数据元素 的 分界线 并且 堆顶对换/互相插入 不影响定义性质 那么当求中位数时 只需调堆即可 得益于堆的性质 每次调堆时间复杂度为log(n) 1.当前总元素量为奇数时 只...
[模板] 矩阵乘法，矩阵快速幂，矩阵幂
Zeolim的博客
03-19 635
1.普通乘法 当且仅当方阵A行等于方阵B列时才可以进行矩阵乘法运算。 #include &lt;iostream&gt; using namespace std; int a[300][300]; int b[300][300]; int ans[300][300]; int main() { int m,s,n; cin&gt;&gt;m&gt;&gt;s&gt;&gt;n; f...
[组合数]lucas定理 排列组合取模
Zeolim的博客
05-05 606
lucas： 计算 C 时 当 n， m范围大 mod范围小时可以将 n m 缩减至 mod 范围内计算 预处理： 当 n m 范围小 mod 范围大时可以预处理阶乘逆元 O（1）计算 const int FN = 1e5 + 10; const int MOD = 1e9 + 7; ll fac[FN] = {1, 1}, inv[FN] = {1,1}, f[FN] = {1,1}; ...
[模板]二维前缀和
Zeolim的博客
02-07 550
一维前缀和极易, 从前至尾依次加和即可. 二维如果仍按一维计和方式 i, j 遍历依次加和的话, emmm并没有什么卵用 查询为O( min( abs(y2 - y1), abs(x2 - x1)) * O(1) 妥妥超时   由此引出二维前缀和的标准统计方式 每单位存储的是到本单位左上矩形所有元素(包括本行本列)和   如图   由容斥证明得: S(d) = S(a+b+...
[模板] 扫描线
Zeolim的博客
08-13 491
一、扫描线求矩形面积并 如图所示 总矩形面积并等于每两根蓝线间的面积和。 考虑将矩形按x轴排序，只需要知道每个离散的x点上被矩形覆盖的长度， 和下一条扫描线的x轴可知之间面积为 所以只需要维护每一条扫描线的长度即可，线段树暴力维护 题目链接https://vjudge.net/problem/POJ-1151 线段树维护 const int MAXN = 1e6 + 1...
[暴力]分块
Zeolim的博客
05-21 489
优化暴力算法 分sqrt(n)个区间进行维护 复杂度3 sqrt(n) = sqrt(n) 代码: 建块 int n, m; ll arr[MAXN] = {0}; //原数组 ll belong[MAXN], bsize = 0; //对应块 块大小 ll fst[MAXN], lst[MAXN], rmax[MAXN] = {0}; //对应块起始地址 块维护信息 void bui...
[模板]主席树及其应用
Zeolim的博客
05-14 465
可持久化权值线段树； root数组记录第i版本根， 每次建树时只新建当前位相关子节点， 不相关子节点直接用上一版本的原节点 有前缀和及权值树性质， 可区间查询k小数 1.查询区间第k小 #include <iostream> #include <cstdio> #include <cstring> #include <algorithm> ...
[牛客寒假算法基础集训营6总结]
Zeolim的博客
04-03 464
A.[简单数学思维递推] 易得m题所组成所有分数集合中极小值m*6 极大值m*9, 因其子和差值均一, 则有若干组合组成连续闭区间[6*m, 9*m] 易推得6数极小时应有其余三数组合极大 则有公式ans = max(-(n - m * ll(6)) + m, ll(0)) (未化简) ---------------------------------------------...
[模板] 快读快写
Zeolim的博客
11-04 464
void re(int &amp;x) { x = 0; char s = getchar(); while(s &lt; '0' || s &gt; '9') s = getchar(); while(s &gt;= '0' &amp;&amp; s &lt;= '9') { x = x * 10 + s - '0'; s = getchar();} } void w...
acwing模板线段树
最新发布
01-20
以下是acwing模板线段树的示例代码： ```cpp const int N = 100010; int n, m; int a[N]; struct Node { int l, r; int v, lazy; } tree[N * 4]; void pushup(int x) { tree[x].v = tree[x * 2].v + tree[x * ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值