线段树模板

P3372 【模板】线段树 1

题目描述

如题，已知一个数列，你需要进行下面两种操作：

1.将某区间每一个数加上x

2.求出某区间每一个数的和

输入格式

第一行包含两个整数N、M，分别表示该数列数字的个数和操作的总个数。

第二行包含N个用空格分隔的整数，其中第i个数字表示数列第i项的初始值。

接下来M行每行包含3或4个整数，表示一个操作，具体如下：

操作1： 格式：1 x y k 含义：将区间[x,y]内每个数加上k

操作2： 格式：2 x y 含义：输出区间[x,y]内每个数的和

输出格式

输出包含若干行整数，即为所有操作2的结果。

输入输出样例
输入 #1

5 5
1 5 4 2 3
2 2 4
1 2 3 2
2 3 4
1 1 5 1
2 1 4

输出 #1

11
8
20

AC代码：

#include<bits/stdc++.h>
using namespace std;
#define ll long long int
//long long int 坑我好久 
#define MAX_size 100005
ll arr[MAX_size];
ll lazy[MAX_size*4];//懒惰标记 
ll tree[MAX_size*4];
void build_tree(int node /*树节点*/,int start,int end)//建树 
{
	if(start==end)
	tree[node]=arr[start];
	else
	{
		int mid=(start+end)>>1;
		int left_node=2*node+1;
		int right_node=2*node+2;
		build_tree(left_node,start,mid);
		build_tree(right_node,mid+1,end);
		tree[node]=tree[left_node]+tree[right_node];
	}
	return;
}
void lazydown(int node,int start,int end,ll k)
{
	lazy[node]+=k;//区间下还有没分配的值 
	tree[node]+=k*(end-start+1);//准确值 
	return;
}
void pushlazy(int node,int start,int end)//下传标记（需要用到node的子树时） 
{
	if(!lazy[node])
	return;
	int mid =(start+end)>>1;
	int left_node=2*node+1;
	int right_node=2*node+2;
	lazydown(left_node,start,mid,lazy[node]);
	lazydown(right_node,mid+1,end,lazy[node]);
	lazy[node]=0;
	return;
}
void update_tree(int node,int start,int end,int l,int r,ll k)//区间修改 +k
{
	if(l<=start&&end<=r)//包含 就直接修改 
	{
		lazydown(node,start,end,k);//区间修改 
		return;
	}
	int mid=(start+end)>>1;
	int left_node=2*node+1;
	int right_node=2*node+2;
	
	pushlazy(node,start,end);//下传标记 
	
	if(l<=mid)//判断在哪边 
	{
		update_tree(left_node,start,mid,l,r,k);
	}
	if(mid<r) 
		update_tree(right_node,mid+1,end,l,r,k);
	//一路往上修改 
	tree[node]=tree[left_node]+tree[right_node];
	return;
}
ll query_tree(int node,int start,int end,int l,int r)//区间查询
{
	if(r<start||l>end)//不在计算范围之内
	{
		return 0;
	}
	if(l<=start&&end<=r)//包含    
	return tree[node];
	
	if(start==end)//正好计算到叶节点
	return tree[node];
	
	pushlazy(node,start,end);//下传标记（需要用到node的子树时）
	//已经把lazy传递到tree里了
	 
	int mid=(start+end)>>1;
	int left_node=2*node+1;
	int right_node=2*node+2;
	ll suml=query_tree(left_node,start,mid,l,r);
	ll sumr=query_tree(right_node,mid+1,end,l,r);
	return suml+sumr;
}
int main(void)
{
	int n,m;
	scanf("%d %d",&n,&m);
	for(int i=0;i<n;i++)//下标从0开始 
	scanf("%lld",&arr[i]);
	build_tree(0,0,n-1);
	while(m--)
	{
		int key,x,y;
		ll k;
		scanf("%d",&key);
		if(key==1)//区间修改 
		{
			scanf("%d %d %lld",&x,&y,&k);
			x--;y--;
			update_tree(0,0,n-1,x,y,k);//区间修改 
		}
		else//区间查询 
		{
			scanf("%d %d",&x,&y);//下标从1开始
			x--;y--;
			printf("%lld\n",query_tree(0,0,n-1,x,y));
		}
	}
	return 0;
}

事实证明，树状数组更快

树状数组代码短，需要了解请看：
树状数组模板
直接上代码吧：

//#include<bits/stdc++.h>
#include<iostream>
using namespace std;
#define ll long long int
int n;//长度  
ll a[1000005];//原输入数组 
ll tree1[1000005];//维护差分数组b 
ll tree2[1000005];//维护i*b[i]  为什么要维护这两个，因为后面区间查询时要求这两个的前缀和 
int lowbit(int x)
{
	return x&(-x); //取反+1就等于 -x 
}//返回的值就是其覆盖的长度 
void add(int x,ll k)//由于维护的是差分数组故相当于区间修改 
{
	for(int i=x;i<=n;i+=lowbit(i))
	tree1[i]+=k,tree2[i]+=x*k;
	return; 
}//层层往父亲节点修改（修改父亲节点的值就是某一段的前缀和） ,所以为i 
/*ll ask(int x)//查询x的前缀和，并计算 a[x]的 前缀和 
{
	ll ans=0ll;
	for(int i=x;i;i-=lowbit(i))
	ans+=(x+1)*tree1[i]-tree2[i];
	return ans;
}*/
//a[x]的前缀和=∑∑d[j]=∑d[i](x-i+1)=(x+1)*(∑d[i])-(∑d[i]*i)     注‘∑’表示1~x求和 
ll ask(ll *z,int x)//单点查询前缀和 
{
	ll ans=0ll;
	for(int i=x;i;i-=lowbit(i))
	ans+=z[i]; 
	return ans;
}
ll rang_ask(int l,int r)//区间查询 
{
	//return ask(r)-ask(l-1); 居然超时 (用第一个ask函数)
	return ((r+1)*ask(tree1,r)-ask(tree2,r)) - ( (l-1 +1)*ask(tree1,l-1)-ask(tree2,l-1) ) ;
}
int main(void)
{
	int q,k;
	ll x;
	scanf("%d %d",&n,&q);
	for(int i=1;i<=n;i++){
		scanf("%lld",&a[i]);
		add(i,a[i]-a[i-1]);//维护差分数组 
	}
	while(q--)
	{
		int key;
		ll r,l;
		scanf("%d",&key);
		if(key==1)//区间【l,r】都加 x
		{
			scanf("%d %d %lld",&l,&r,&x);
			//由于树状数组维护的是差分数组： 
			add(l,x);
			add(r+1,-x);
		}
		else//求区间和，就是求 两个前缀和的差 ！ 
		{
			scanf("%d %d",&l,&r);
			printf("%lld\n",rang_ask(l,r));
		}
	}
	return 0;
}