线段树/树状数组

线段树/树状数组

***（个人学习笔记，十分不严谨） ***

1. 线段数(二叉树节点的值称根值，自命)

• 区间修改，区间查询

  1>Segtreenode是节点结构体（一般是n的4倍就够了），lazy表示延迟值（修改区间值暂时存储,表示该区间每个点要增加多少），val表示整个区间的值的总和（由于是完全二叉树，所以由左儿子和右儿子的val和得到）。
  2>build函数(参数：左边界、右边界、边界所属的根值)构造完全二叉树，将每个节点的lazy延迟值初始化为0，当左右边界一样时，也就是到了最底层叶子，叶子的边界值l和r等于数组A的下角标，存入节点的val值，并返回（最开始是一直到底的，然后返回叶子的val，得到父节点的val值）；如果左右边界不一样，取中间值往下构造。
  3>pushup函数（参数：父节点根值rt），由左右子节点val和得到rt节点的val。
  4>update函数（参数：查询区间LR，添加范围C，操作范围lr，操作范围所属节点rt）用于区间更新，如果操作范围完全在查找范围，那可以对操作范围的所属节点操作即可，不用更新完区间所有值。对该节点val值增加该范围所全部增加的和，然后延迟值增加C；如果操作范围完全不在查询范围，直接返回；如果只有部分在查询范围，取中间值向下更新（在此之前pushdown()）。
  5>pushdown函数，下放节点的延迟值，并清除节点的延迟值（把存的延迟值放下去）。

//洛谷P3372
#include<bits/stdc++.h>
using namespace std;
#define maxn 100007
#define ll long long
ll A[maxn],n,m;
struct Segtreenode
{
	ll val;
	ll lazy;
}Segtree[maxn<<2];
void pushup(ll rt)
{
	Segtree[rt].val=Segtree[rt<<1].val+Segtree[rt<<1|1].val;
}
void build(ll l,ll r,ll rt)
{
	Segtree[rt].lazy=0;//延迟值初始化 
	if(l==r)//l==r的是叶子，将叶子值赋给第rt点 
	{
		Segtree[rt].val=A[l];
		return; 
	}
	ll m=(l+r)>>1;
	build(l,m,rt<<1);//rt*2是左儿子的根值，范围是l~m;
	build(m+1,r,rt<<1|1);//右子树
	pushup(rt);//更新父节点的val值 
}
void pushdown(ll rt,ll ln,ll rn)
{
	if(Segtree[rt].lazy)//根rt存有延迟值，往下开始分配 
	{
		Segtree[rt<<1].val+=Segtree[rt].lazy*ln;
		Segtree[rt<<1|1].val+=Segtree[rt].lazy*rn;
		//更新左右子节点的val
		Segtree[rt<<1].lazy+=Segtree[rt].lazy;
		Segtree[rt<<1|1].lazy+=Segtree[rt].lazy;
		//更新左右子节点的延迟值
		Segtree[rt].lazy=0; 
	} 
}
void update(ll L,ll R,ll C,ll l,ll r,ll rt)
{
	if(L<=l&&r<=R)//lr在更新区间LR里面
	{
		Segtree[rt].val+=C*(r-l+1);
		Segtree[rt].lazy+=C;
		return;
	}
	if(R<l||L>r)return;//lr完全不在查询区间 
	ll m=(l+r)>>1;
	pushdown(rt,m-l+1,r-m);
	//lr部分在查询区间
	update(L,R,C,l,m,rt<<1);
	update(L,R,C,m+1,r,rt<<1|1); 
	pushup(rt);
}
ll query(ll L,ll R,ll l,ll r,ll rt)
{
	if(L<=l&&r<=R)
	{
		return Segtree[rt].val;
	}
	if(R<l||L>r)return 0;
	ll m=(l+r)>>1;
	pushdown(rt,m-l+1,r-m);
	return query(L,R,l,m,rt<<1)+query(L,R,m+1,r,rt<<1|1);
}

int main()
{
	scanf("%d%d",&n,&m);
	for(ll i=1;i<=n;i++)
	{
		cin>>A[i];
	}
	build(1,n,1);
	while(m--)
	{
		int t;cin>>t;
		if(t==1)
		{
			ll x,y,k;cin>>x>>y>>k;
			update(x,y,k,1,n,1);
			/*xy是不变的更新区间，
			update函数缩小1-n
			（lr）的范围*/
		}
		else
		{
			ll x,y;cin>>x>>y;
			cout<<query(x,y,1,n,1)<<endl;
			 
		}
	 } 
	return 0;
}

树状数组

（树状数组的存储方式）

可以看到c[i]的存储个数为二进制最后一个1所代表的数字，可以用lowbit(x)求得，不赘述。

单点修改，区间查询

构造树状数组时就相当于进行单点修改。
每次修改都要在包含这个点的树上修改。
区间查询（x，y）就是求sum（1到y）-sum(1到x-1)

ll t,n,m;
const int maxn=5e5+10;

ll tree[maxn]={0};
void update(ll x,ll k){
	for(ll i=x;i<=n;i+=lowbit(i)){
		tree[i]+=k;
	}
}
ll query(ll x,ll y){
	ll sumx=0,sumy=0;
	while(x>0){
		sumx+=tree[x];
		x-=lowbit(x);
	}
	while(y>0){
		sumy+=tree[y];
		y-=lowbit(y);
	}
	return sumy-sumx;
}
void solve(){
	cin>>n>>m;
	
	for(ll i=1;i<=n;i++){
		ll x;cin>>x;
		update(i,x);
	}
	
	while(m--){
		ll p,x,y;cin>>p>>x>>y;
		if(p==1){
			update(x,y);
		}else{
			cout<<query(x-1,y)<<endl;
		}
	}
}

区间修改，单点查询

理论上讲区间修改可以看作多个单点修改，但容易爆。
现将树状数组改为树状差分数组，即树状数组对应的原数组存储的是相邻两数的差，这样区间内进行修改时，差值不变，对边缘进行修改即可

ll t,n,m;
const int maxn=5e5+10;

ll tree[maxn]={0};
void update(ll x,ll k){
	for(ll i=x;i<=n;i+=lowbit(i)){
		tree[i]+=k;
	}
}
ll query(ll x,ll y){
	ll sumx=0,sumy=0;
	while(x>0){
		sumx+=tree[x];
		x-=lowbit(x);
	}
	while(y>0){
		sumy+=tree[y];
		y-=lowbit(y);
	}
	return sumy-sumx;
}
void solve(){
	cin>>n>>m;
	ll lx=0;
	for(ll i=1;i<=n;i++){
		ll x;cin>>x;
		update(i,x-lx);
		lx=x;
	}
	
	while(m--){
		ll p;cin>>p;
		if(p==1){
			ll x,y,k;
			cin>>x>>y>>k;
			update(x,k);
			update(y+1,-k);
		}else{
			ll x;cin>>x;
			cout<<query(0,x)<<endl;
		}
	}
}