线段树1板子 区间加

目录

线段树的结构关系——大小为什么是4n

int作为下标的: 

long long作为下标的:


注意本板子下标从1开始,因为涉及二叉树的计算。

类的构造函数写在类最后了,本板子没有将左右下标封装到节点中,而是实时计算的。

建议阅读:线段树 - OI Wiki (oi-wiki.org)

全览:

线段树的结构关系——大小为什么是4n

这是一颗线段树,a[5] = {10,11,12,13,14} 

可以看出5个节点对应下图二叉树的话,其实节点到了第4层:

//		  1
//	  2      3			2^1
//	4   5  6   7		2^2
// 8 9					2^3
//1		log1==0
//2		log2==1		log3==1
//4		log4==2		log5==log6==log7==2
//8
//
//对于 log5 == 2, 其实5在第三层,所以层数是 log5 + 1 
//(4也一样)
// 
//完全二叉树的总结点数就是:
//等比数列求和
//1 2 4 8 
//1*(2^m  - 1)/(2-1)
//
//因为是logn + 1层
//pow(2,(int)log2(n)+1)-1
//

再由上图可知,需要再下一层
所以是pow(2,(int)log2(n)+1 +1 )-1

因为我们是从1开始的,所以数组大小要加1,
所以是pow(2,(int)log2(n)+2)

化简它,就是 n * 2 * 2 

也就是4n啦

int作为下标的: 

#define int long long
#define ll long long 
template<class T>
class ST//segment tree
{
	struct node
	{
		T val;
		T t;//懒标记//服务后代
		node(T v = 0) :val(v), t(0)
		{}
	};
	int n = a.size();
	vector<T>a;
	vector<node>d;
	void build_tree(int i, int l, int r)
	{
		if (l == r)
		{
			d[i].val = a[l];
			return;
		}
		int mid = l + (r - l) / 2;
		build_tree(i * 2, l, mid);
		build_tree(i * 2 + 1, mid + 1, r);
		d[i].val = d[i * 2].val + d[i * 2 + 1].val;
	}
	void spread(int i, int l, int r, int aiml, int aimr)
	{
		int mid = l + (r - l) / 2;
		if (d[i].t != 0 && l != r)
		{
			d[i * 2].val += d[i].t * (mid - l + 1);
			d[i * 2 + 1].val += d[i].t * (r - mid);
			d[i * 2].t += d[i].t;//可能上上次也没改
			d[i * 2 + 1].t += d[i].t;
			d[i].t = 0;
		}
	}
	T _getsum(int i, int l, int r, int aiml, int aimr)
	{
		if (aiml <= l && r <= aimr)//查询区间的子集全部加起来
			return d[i].val;

		//访问
		int mid = l + (r - l) / 2;
		spread(i, l, r, aiml, aimr);

		T ret = 0;
		if (aiml <= mid)
			ret += _getsum(i * 2, l, mid, aiml, aimr);
		if (aimr >= mid + 1)
			ret += _getsum(i * 2 + 1, mid + 1, r, aiml, aimr);
		return ret;

	}
	void _update(int i, int l, int r, int aiml, int aimr, ll val)
	{
		if (aiml <= l && r <= aimr)
		{
			d[i].val += val * (r - l + 1);
			d[i].t += val;
			return;
		}


		int mid = l + (r - l) / 2;
		spread(i, l, r, aiml, aimr);

		if (aiml <= mid)
			_update(i * 2, l, mid, aiml, aimr, val);
		if (aimr >= mid + 1)
			_update(i * 2 + 1, mid + 1, r, aiml, aimr, val);
		//我们只对叶子更新了,(别多想懒标记)
		d[i].val = d[i * 2].val + d[i * 2 + 1].val;
	}
public:
	T getsum(int l, int r)
	{
		return _getsum(1, 1, n, l, r);
	}
	void update(int l, int r, ll val)
	{
		_update(1, 1, n, l, r, val);//加并挂标记
	}
	ST(vector<T>arr)
	{
		a = arr;
		n = a.size() - 1;
		d = vector<node>(4*n);
		build_tree(1, 1, n);
	}
};

long long作为下标的:

#define ll long long
template<class T>
class ST//segment tree
{
	struct node
	{
		T val;
		T t;//懒标记//服务后代
		node(T v = 0) :val(v), t(0)
		{}
	};
	ll n = a.size();
	vector<T>a;
	vector<node>d;
	void build_tree(ll i, ll l, ll r)
	{
		if (l == r)
		{
			d[i].val = a[l];
			return;
		}
		ll mid = l + (r - l) / 2;
		build_tree(i * 2, l, mid);
		build_tree(i * 2 + 1, mid + 1, r);
		d[i].val = d[i * 2].val + d[i * 2 + 1].val;
	}
	void spread(ll i, ll l, ll r, ll aiml, ll aimr)
	{
		ll mid = l + (r - l) / 2;
		if (d[i].t != 0 && l != r)
		{
			d[i * 2].val += d[i].t * (mid - l + 1);
			d[i * 2 + 1].val += d[i].t * (r - mid);
			d[i * 2].t += d[i].t;//可能上上次也没改
			d[i * 2 + 1].t += d[i].t;
			d[i].t = 0;
		}
	}
	T _getsum(ll i, ll l, ll r, ll aiml, ll aimr)
	{
		if (aiml <= l && r <= aimr)//查询区间的子集全部加起来
			return d[i].val;

		//访问
		ll mid = l + (r - l) / 2;
		spread(i, l, r, aiml, aimr);

		T ret = 0;
		if (aiml <= mid)
			ret += _getsum(i * 2, l, mid, aiml, aimr);
		if (aimr >= mid + 1)
			ret += _getsum(i * 2 + 1, mid + 1, r, aiml, aimr);
		return ret;

	}
	void _update(ll i, ll l, ll r, ll aiml, ll aimr, ll val)
	{
		if (aiml <= l && r <= aimr)
		{
			d[i].val += val * (r - l + 1);
			d[i].t += val;
			return;
		}


		ll mid = l + (r - l) / 2;
		spread(i, l, r, aiml, aimr);

		if (aiml <= mid)
			_update(i * 2, l, mid, aiml, aimr, val);
		if (aimr >= mid + 1)
			_update(i * 2 + 1, mid + 1, r, aiml, aimr, val);
		//我们只对叶子更新了,(别多想懒标记)
		d[i].val = d[i * 2].val + d[i * 2 + 1].val;
	}
public:
	T getsum(ll l, ll r)
	{
		return _getsum(1, 1, n, l, r);
	}
	void update(ll l, ll r, ll val)
	{
		_update(1, 1, n, l, r, val);//加并挂标记
	}
	ST(vector<T>arr)
	{
		a = arr;
		n = a.size() - 1;
		d = vector<node>(n*4);
		build_tree(1, 1, n);
	}
};

  • 20
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 3
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值