线段树 && 区间修改 && 区间查询 && 懒惰标记

线段树

线段树将每个长度不为 1 的区间划分成左右两个区间递归求解，把整个线段划分为一个树形结构，通过合并左右两区间信息来求得该区间的信息。这种数据结构可以方便的进行大部分的区间操作。使得区间修改操作的时间复杂度降为O（logn）

线段树基本知识

1. 建树范围：树长为四倍的原数组长度即可。即有一个长度为n的数组，建立线段树去维护，只需线段树数组长度为4n即可，绝对够用。
2. 建树操作，区间操作都从根节点开始，根节点是所有节点的和，所有节点都可以通过根节点来遍历到。
3. 一个节点的左儿子节点的下标是其下标的俩倍，右儿子的下标是其下标的俩倍加一。
4. 如果父亲节点所维护的数组范围是[s, t] ，那么左儿子节点所维护的数组范围便是[s, (s+t)/2] ，右儿子节点所维护的数组范围便是[(s+t)/2+1, t]。
5. 懒惰标记是为了节约时间所建立的，在更新时可以仅更新当前节点，然后打上懒惰标记，在下次遍历到时下传标记。

建树操作

以下[s, t]区间统称为当前节点所维护的区间，[l, r]区间为需要操作的区间。

void build(ll node, ll s, ll t)
{
	if(s==t){
		tree[node] = a[s];
		return;
	}
	int m=(s+t) / 2;
	build(node*2, s, m), build(node*2+1, m+1, t);
	tree[node] = tree[node*2] + tree[node*2+1];
	return ;
}

区间查询

ll getsum(ll l, ll r, ll s, ll t, ll node)
{
	if(s>=l && t<=r) return tree[node];
	ll m = (s+t)/2;
	if(b[node] && s!=t)
	{
		tree[node*2] += b[node]*(m-s+1);
		tree[node*2+1] += b[node]*(t-m);
		b[node*2] += b[node], b[node*2+1] += b[node];
		b[node] = 0;
	}
	ll sum=0;
	if (l <= m) sum += getsum(l, r, s, m, node * 2);
    if (r > m) sum += getsum(l, r, m + 1, t, node * 2 + 1);
    return sum;
 } 

区间修改

void update(ll l, ll r, ll s, ll t, ll k, ll node)
{
	if(s>=l && t<=r)
	{
		tree[node] += (t-s+1)*k;
		b[node] += k;
		return ;
	}
	int m = (s+t) / 2;
	if(b[node] && s!=t)
	{
		tree[node*2] += b[node]*(m-s+1), tree[node*2+1] += b[node]*(t-m);
		b[node*2] += b[node], b[node*2+1] += b[node];
		b[node]=0;
	}
	if(l<=m) update(l, r, s, m, k, node*2);
	if(r>m) update(l, r, m+1, t, k, node*2+1);
	tree[node] = tree[node*2] + tree[node*2+1];
}

洛谷模板题P3372

参考代码

#include<iostream>
using namespace std;
typedef long long ll;

ll n, m;
ll tree[400005];
ll b[400005];
ll a[100005];

void build(ll node, ll s, ll t)
{
	if(s==t){
		tree[node] = a[s];
		return;
	}
	int m=(s+t) / 2;
	build(node*2, s, m), build(node*2+1, m+1, t);
	tree[node] = tree[node*2] + tree[node*2+1];
	return ;
}

void update(ll l, ll r, ll s, ll t, ll k, ll node)
{
	if(s>=l && t<=r)
	{
		tree[node] += (t-s+1)*k;
		b[node] += k;
		return ;
	}
	int m = (s+t) / 2;
	if(b[node] && s!=t)
	{
		tree[node*2] += b[node]*(m-s+1), tree[node*2+1] += b[node]*(t-m);
		b[node*2] += b[node], b[node*2+1] += b[node];
		b[node]=0;
	}
	if(l<=m) update(l, r, s, m, k, node*2);
	if(r>m) update(l, r, m+1, t, k, node*2+1);
	tree[node] = tree[node*2] + tree[node*2+1];
}

ll getsum(ll l, ll r, ll s, ll t, ll node)
{
	if(s>=l && t<=r) return tree[node];
	ll m = (s+t)/2;
	if(b[node] && s!=t)
	{
		tree[node*2] += b[node]*(m-s+1);
		tree[node*2+1] += b[node]*(t-m);
		b[node*2] += b[node], b[node*2+1] += b[node];
		b[node] = 0;
	}
	ll sum=0;
	if (l <= m) sum += getsum(l, r, s, m, node * 2);
    if (r > m) sum += getsum(l, r, m + 1, t, node * 2 + 1);
    return sum;
 } 

int main()
{
	scanf("%lld%lld", &n, &m);
	for(ll i=1;i<=n;i++)
		scanf("%lld", &a[i]);
	build(1,1,n);
	ll flag;
	while(m--)
	{
		scanf("%lld", &flag);
		if(flag==1){
			ll x, y, k;
			scanf("%lld%lld%lld", &x, &y, &k);
			update(x, y, 1, n, k, 1);
		}else{
			ll x, y;
			scanf("%lld%lld", &x, &y);
			cout << getsum(x, y, 1, n, 1) << endl;
		}
	}
	return 0;
 } 

谢谢观看！