Day52 树状数组 线段树（lazy标记）

最新推荐文章于 2022-07-06 11:12:49 发布
最新推荐文章于 2022-07-06 11:12:49 发布
阅读量3.4k 收藏
点赞数
分类专栏： 日更学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43982216/article/details/107107297
版权

动态求连续区间和
树状数组是利用lowbit的性质求前缀和

lowbit(x)= 2 k 2^{k} 2k,k的意思是x的二进制表达最后面有几位0
然后c[x]是对 [ x − 2 k , x ] [x-2^{k},x] [x−2k,x]范围内的q求和
然后修改，询问区间和都用到这个性质

#include<vector>
#include<cstring>
#include<cstdio>
#include<iostream>
#include<string>
#include<map>
#include<queue>
#include<algorithm>
#include<ctime>
#include<cmath>
#include<cstdlib>
#define lson (o<<1)
#define rson (o<<1|1)
#define fi first
#define sc second
#define dbg(x) cout<<#x<<" = "<<(x)<<endl;
#define rg register
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
using namespace std;
const double pi=acos(-1);
const double eps=1e-6;
inline int lowbit(int x){return x&(-x);}

template<typename A,typename B,typename C> inline A fpow(A x,B p,C yql){
	A ans=1;
	for(;p;p>>=1,x=1LL*x*x%yql)if(p&1)ans=1LL*x*ans%yql;
	return ans;
}


inline int read()
{
    int X=0,w=1;
    char c=getchar();
    while(c<'0'||c>'9')
    {
        if (c=='-')
        {
            w=-1;
        }
        c=getchar();
    }
    while(c>='0'&&c<='9')
    {
        X=(X<<3)+(X<<1)+(c^48);
        c=getchar();
    }
    return X*w;
}
//inline void w(int x) { if(x>9) w(x/10); putchar(x%10+'0'); }
const int N=1e5+10; 
ll T;
int q[N],c[N],n,m;
#define lowbit(x) (x&-x)

void add(int a,int b){
	for(int i=a;i<=n;i+=lowbit(i)){
		c[i]+=b;
	}
}
int getsum(int a){
	int res=0;
	for(int i=a;i;i-=lowbit(i)){
		res+=c[i];
	}
	return res;
}
void solve(){
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		cin>>q[i];
		add(i,q[i]);
	}
	int op,a,b;
	for(int i=0;i<m;i++){
		cin>>op>>a>>b;
		if(op==0){
			cout<<getsum(b)-getsum(a-1)<<endl;
		}else {
			add(a,b);
		}
	}
}


int main(){
	std::ios::sync_with_stdio(0);
	std::cin.tie(0);
	T=1;
	//cin>>T;
	while(T--){
		solve();
	}
	return 0;
}

数星星
注意增加星星的时候是增加在32000范围内的星星
所以add的范围扩大到32000

然后要注意y是递增输入的
所以可以直接一行一行的增加我们的树状数组

#include<vector>
#include<cstring>
#include<cstdio>
#include<iostream>
#include<string>
#include<map>
#include<queue>
#include<algorithm>
#include<ctime>
#include<cmath>
#include<cstdlib>
#define lson (o<<1)
#define rson (o<<1|1)
#define fi first
#define sc second
#define dbg(x) cout<<#x<<" = "<<(x)<<endl;
#define rg register
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
using namespace std;
const double pi=acos(-1);
const double eps=1e-6;
inline int lowbit(int x){return x&(-x);}

template<typename A,typename B,typename C> inline A fpow(A x,B p,C yql){
	A ans=1;
	for(;p;p>>=1,x=1LL*x*x%yql)if(p&1)ans=1LL*x*ans%yql;
	return ans;
}


inline int read()
{
    int X=0,w=1;
    char c=getchar();
    while(c<'0'||c>'9')
    {
        if (c=='-')
        {
            w=-1;
        }
        c=getchar();
    }
    while(c>='0'&&c<='9')
    {
        X=(X<<3)+(X<<1)+(c^48);
        c=getchar();
    }
    return X*w;
}
//inline void w(int x) { if(x>9) w(x/10); putchar(x%10+'0'); }
const int N=32010;
ll T;
int q[N],level[N],n,ans[N];


void add(int a){
	for(int i=a;i<=N;i+=lowbit(i)){
		level[i]++;
	}
}

int getsum(int a){
	int res=0;
	for(int i=a;i;i-=lowbit(i)){
		res+=level[i];
	}
	return res;
}

void solve(){
	cin>>n;
	int x,y;
	for(int i=0;i<n;i++){
		cin>>x>>y;
		x++;
		ans[getsum(x)]++;
		add(x);

	} 
	
	for(int i=0;i<n;i++)cout<<ans[i]<<endl;
}
//01122

int main(){
	std::ios::sync_with_stdio(0);
	std::cin.tie(0);
	T=1;
	//cin>>T;
	while(T--){
		solve();
	}
	return 0;
}

线段树
下面是query中l和r不修改的原因
因为tr[u].l+tr[u].r>>1和区间毫无关系
甚至可能扩大查询区间
比如下面查询[1，3]
就会把3扩大成5
从而查询到45的结果
在这里插入图片描述
线段树

#include<vector>
#include<cstring>
#include<cstdio>
#include<iostream>
#include<string>
#include<map>
#include<queue>
#include<algorithm>
#include<ctime>
#include<cmath>
#include<cstdlib>
#define lson (o<<1)
#define rson (o<<1|1)
#define fi first
#define sc second
#define dbg(x) cout<<#x<<" = "<<(x)<<endl;
#define rg register
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
using namespace std;
const double pi=acos(-1);
const double eps=1e-6;
inline int lowbit(int x){return x&(-x);}

template<typename A,typename B,typename C> inline A fpow(A x,B p,C yql){
	A ans=1;
	for(;p;p>>=1,x=1LL*x*x%yql)if(p&1)ans=1LL*x*ans%yql;
	return ans;
}


inline int read()
{
    int X=0,w=1;
    char c=getchar();
    while(c<'0'||c>'9')
    {
        if (c=='-')
        {
            w=-1;
        }
        c=getchar();
    }
    while(c>='0'&&c<='9')
    {
        X=(X<<3)+(X<<1)+(c^48);
        c=getchar();
    }
    return X*w;
}
//inline void w(int x) { if(x>9) w(x/10); putchar(x%10+'0'); }
const int N=1e5+10;
ll T;
struct node{
	int l,r,sum;
}tr[N*4];
int q[N];

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

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

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

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

void solve(){
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		cin>>q[i];
	}
	build(1,1,n);
	int op,a,b;
	for(int i=0;i<m;i++){
		cin>>op>>a>>b;
		if(op){
			add(1,a,b);
		}else{
			cout<<query(1,a,b)<<endl;
		}
	}
}


int main(){
	std::ios::sync_with_stdio(0);
	std::cin.tie(0);
	T=1;
	//cin>>T;
	while(T--){
		solve();
	}
	return 0;
}

lazy标记的线段树

#include<vector>
#include<cstring>
#include<cstdio>
#include<iostream>
#include<string>
#include<map>
#include<queue>
#include<algorithm>
#include<ctime>
#include<cmath>
#include<cstdlib>
#define lson (o<<1)
#define rson (o<<1|1)
#define fi first
#define sc second
#define dbg(x) cout<<#x<<" = "<<(x)<<endl;
#define rg register
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
using namespace std;
const double pi=acos(-1);
const double eps=1e-6;
inline int lowbit(int x){return x&(-x);}

template<typename A,typename B,typename C> inline A fpow(A x,B p,C yql){
	A ans=1;
	for(;p;p>>=1,x=1LL*x*x%yql)if(p&1)ans=1LL*x*ans%yql;
	return ans;
}


inline int read()
{
    int X=0,w=1;
    char c=getchar();
    while(c<'0'||c>'9')
    {
        if (c=='-')
        {
            w=-1;
        }
        c=getchar();
    }
    while(c>='0'&&c<='9')
    {
        X=(X<<3)+(X<<1)+(c^48);
        c=getchar();
    }
    return X*w;
}
//inline void w(int x) { if(x>9) w(x/10); putchar(x%10+'0'); }
const int N=1e5+10;
ll T;
struct node{
	int l,r;
	ll sum,add;
	#define l(x) tree[x].l
	#define r(x) tree[x].r
	#define sum(x) tree[x].sum
	#define add(x) tree[x].add
}tree[4*N];
ll q[N];

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

void spread(int u){
	if(add(u)){
		sum(u<<1)+=add(u)*(r(u<<1)-l(u<<1)+1);
		sum(u<<1|1)+=add(u)*(r(u<<1|1)-l(u<<1|1)+1);
		add(u<<1)+=add(u);
		add(u<<1|1)+=add(u);
		add(u)=0;
	}
}

void change(int u,int l,int r,int v){
	if(l(u)>=l&&r(u)<=r){
		sum(u)+=(ll)v*(r(u)-l(u)+1);
		add(u)+=v;
		return;
	}
	spread(u); 
	int mid=l(u)+r(u)>>1;
	if(l<=mid)change(u<<1,l,r,v);
	if(r>mid)change(u<<1|1,l,r,v);
	sum(u)=sum(u<<1)+sum(u<<1|1);
}

ll query(int u,int l,int r){
	if(l(u)>=l&&r(u)<=r){
		return sum(u);
	}
	spread(u);
	int mid=l(u)+r(u)>>1;
	ll sum=0;
	if(l<=mid)sum+=query(u<<1,l,r);
	if(r>mid) sum+=query(u<<1|1,l,r);
	return sum;
}

void solve(){
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++)cin>>q[i];
	build(1,1,n);
	int op,x,y;
	while(m--){
		cin>>op;
		if(op==1){
			cin>>x>>y;
			change(1,x,x,y);
		}else {
			cin>>x>>y;
			cout<<query(1,x,y)<<endl;
		//	query(1,x,y);
		}
	}
}


int main(){
	std::ios::sync_with_stdio(0);
	std::cin.tie(0);
	T=1;
	//cin>>T;
	while(T--){
		solve();
	}
	return 0;
}

最好把lson和rson封装

真的会写错。。。。

然后注意mid缩小范围只在build中出现
spread要在判断完边界后立刻执行

离开那天
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线段树（lazy标记）-- 模板
等我，等我变的更好就去找你
06-08 1285
题意： 一个数组A[1::n]，初始值全为0，m 个操作： 1. 使区间[L; R] 内每个数都加上v 2. 查询区间[L; R] 内所有数的和 数据范围: 1 &amp;lt;= n &amp;lt;= 106, 1 &amp;lt;= m &amp;lt;= 106, |v| &amp;lt;=1e3 时限4 秒 题解： 区间修改（带lazy 标记）、区间查询的线段树可以在O(log n)的时间内维护区间的和. 此...
带标记的线段树 - Acwing： 一个简单的整数问题 Python题解
m0_55529377的博客
08-25 308
带标记的线段树 - Acwing 242. 一个简单的整数问题
线段树之lazy数组
bllsll
06-25 636
lazy 用于区间更新。 总结一下，线段树中lazy一些情况 Just a Hook HDU - 1698 题意：开始n个塔的值都是1，然后给你很多个操作，分别是 x y 1 x y 2 x y 3 表示将x到y 之间都值都改成1或2或3 这个用lazy进行更新的时候， 是 lazy[i lazy[i lazy[i]=0; 因为这个题更新是有顺序的，之后的更新会把之前
线段树(lazy用法)
malloch的博客
08-14 2097
在上一篇中，我们讨论了线段树的基础用法，其中我们对于线段树的修改，仅仅限制于对于线段树的点的修改，而不是对于某一个一段区间的修改。 那么我们现在来想想如果对于线段树的一段区间来进行修改的话，如果我们还是来对线段树的每一个点都进行修改的话，那么，假设我们需要修改m个点，其时间复杂度岂不是为O(log(n))了，那么我们所需要的少的时间复杂度的要求就没有达成，为此，lazy数组应运而生，来解决这个问题。 首先我们来认识一下lazy：如果当前区间被需要修改的目标区间完全覆盖，打一个标记。如果下一次的查询或者更改包
回档|带标记的线段树
weixin_33811961的博客
04-05 75
果然还是递归线段树好理解啊，写了个模板题，用了黄学长的模板。codevs的线段树练习3. 代码： #include"iostream" #include"cstdio" using namespace std; struct node{ int s,t,sum,lab; }tr[800001]; int n,q; int a[200001]; int rea...
线段树（单点查询+区间求和）无lazy标记
01-20
在“线段树（单点查询+区间求和）无lazy标记”这个题目中，主要涉及到线段树的基本操作，包括如何构建线段树、单点修改以及区间求和。 1. **线段树的构建**： - `build`函数是线段树的初始化过程。它从根节点开始...
树状数组_洛谷_树状数组_
10-02
树状数组，也被称为线段树（Segment Tree），是一种数据结构，主要用于高效地处理动态区间查询和修改问题。在编程竞赛和算法设计中，树状数组是解决许多问题的利器，尤其是在面对需要频繁更新和查询区间信息的问题时...
线段树模版（比较基本的线段树以及例题模板）
11-01
这篇内容主要包含了一些我写的线段树的代码，可以帮助大家更好的理解线段树建树，lazy_tag，和区间修改，区间最大值一系列的内容。 如果有需要的话可以下载看看。希望能帮助大家。 这几份代码仅供参考，不要抄袭，...
poj2823.cpp.tar.gz_线段树
09-20
线段树通常用于解决动态规划问题，特别是在数组或序列上执行范围查询和修改时，能提供O(log n)的时间复杂度。 线段树的基本概念： 线段树是由一个完全二叉树形成的结构，每个节点代表一个区间，根节点代表整个数组...
树状数组-20-子查询.ev4.rar
最新发布
06-10
树状数组，也被称为线段树（Segment Tree），是一种数据结构，主要用于处理一系列连续的区间或段上的数据更新和查询。在计算机科学中，尤其是在算法竞赛和数据结构课程中，树状数组是一种非常重要的工具，它能高效地...
带简单懒标记的线段树
ykn37的博客
07-06 157
带简单懒标记的线段树
带懒标记的线段树讲解 + 例题AcWing 243. 一个简单的整数问题2
Jacob0824的博客
02-16 480
算法介绍 在线段树的 “ask区间查询” 指令中，每当遇到被询问区间[L,r] 完全覆盖的节点 时，可以立即把 该节点上存储的信息 作为候选答案 返回。可以证明，被询问区间[L,r]在线段树上会被分成O(log N)个小区间(节点),从而在 O(log N)的时间内求出答案。 不过，在 “modify区间修改” 指令中，如果某个节点被修改区间[L,r]完全覆盖，那么 以 该节点为根 的 整棵子树 中的 所有节点存储的信息 都会发生 变化,如果 逐一更新,将使得 一次区间修改指令 的 时间复杂度 增
区区区间(线段树,lazy数组)
weixin_47701814的博客
01-17 226
牛客小白月赛20 E 区区区间 题目链接 算法分析 线段树,区间修改,区间查询,要用到lazy数组去更新(查询和更新过程都要去更新) 代码实现 #include<iostream> #include<math.h> #include<algorithm> using namespace std; typedef long long ll; const int maxn=2e5+5; struct node { int l,r; ll sum,lazy;
hdu3577(线段树+lazy+样例解释+代码解析)
dreamzuora的博客
10-10 2469
Description Chinese always have the railway tickets problem because of its' huge amount of passangers and stations. Now goverment need you to develop a new tickets query system.  One train can jus
poj3468 线段树--lazy标记（使用数组建树）
Krismile_的博客
11-20 194
Description You haveNintegers,A1,A2, ... ,AN. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The other is to...
树状数组总结
skymeteorite
05-17 279
这几天又把树状数组复习一下，感觉又学到了写新东西，把模板写下来，还有自己的一些想法。 首先lowbit函数 int lowbit(int x) { reutrn x&amp;(-x); } 首先，定位lowbit(natural)为自然数(即1,2,3…n)的二进制形式中最右边出现1的值。 比如：4 = 100，lowbit(4) = 4；36 = 100100，lowbit(...
A Simple Problem with Integers POJ - 3468（线段树+区间查询+区间修改+建树+懒惰标记模板）+（树状数组）
zeng_jun_yv的博客
08-02 210
题意： 有一个数组，有两种操作。1: Q a b 求[a,b]的和 2：C a b c 给[a,b] 的所有元素都加上c。 题目： You haveNintegers,A1,A2, ... ,AN. You need to deal with two kinds of operations. One type of operation is to add some given nu...
【树状数组详解】
来日浅谈的博客
10-04 556
【树状数组详解】什么是树状数组树状数组的基本操作单点更新区间查询树状数组与线段树的比较树状数组的整体代码（例：HDU - 1166 排兵布阵） 什么是树状数组 树状数组是一个查询和修改复杂度都为log(n)的数据结构。主要用于数组的单点修改&&区间求和. 另外一个拥有类似功能的是线段树. 具体区别和联系如下： 两者在复杂度上同级, 但是树状数组的常数明显优于线段树, 其编程复杂度...
线段树区间修改（lazy数组）
小帅哥快来看啊的博客
02-17 516
先贴个old hand的博客 https://blog.csdn.net/u012469987/article/details/41357377 讲的很详细，主要看里面的lazy。 贴个题 A Simple Problem with Integers You have N integers, A1, A2, … , AN. You need to deal with two kinds of op...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值