线段树之区间求和
这是我的第一篇博客,希望大家能看的清楚明白。
先声明一下我的代码风格吧!我个人喜欢一般先把main()全部写完,然后再定义内部调用的各个函数,先把整个程序的框架写好,再去实现具体的细节,希望不会影响到大家的阅读。头文件就是常用的头文件,预处理我会事先说明的。
这也是我做的第一个区间更新的题目,感觉好辛苦的说。
Question:
Description:
给出了一个序列,你需要处理如下两种询问。
“C a b c”表示给[a, b]区间中的值全部增加c (-10000 ≤ c ≤ 10000)。
“Q a b” 询问[a, b]区间中所有值的和。
Input:
第一行包含两个整数N、 Q(1 ≤ N,Q ≤ 100000)。
第二行包含n个整数,表示初始的序列A (-1000000000 ≤ A[i] ≤ 1000000000)。
接下来Q行询问,格式如题目描述。
Output:
对于每一个Q开头的询问,你需要输出相应的答案,每个答案一行。
Sample Input:
10 5
1 2 3 4 5 6 7 8 9 10
Q 4 4
Q 1 10
Q 2 4
C 3 6 3
Q 2 4
Sample Output:
4
55
9
15
Answer:
数据预处理一般是数据范围的指定:
#define MAX 100010
自定义数据类型:对于线段树,我只会用结构体数组来表示,结构体包含的是区间范围,以及我们要维护的对象和所需要的标记。
区间更新不同于单点更新,单点更新是即时的,每一次更新都会更新整棵线段树,而区间更新的思想是延迟更新,即在我们需要查询的时候才更新线段树相应的节点,用不到的话自然就不用去维护了,采用这种思想来提高效率。因此在这个题我们需要设立一个延迟标记,表示这个区间是否需要被更新。
所以结构体的设置如下所示(注意数据范围):
struct Tree
{
int left,right;//区间上下限
long long delay,sum;//延迟标记和要维护的对象
}tr[MAXN*4];
接下来是main():
int main()
{
int N,Q;
while(scanf("%d%d",&N,&Q)==2)//支持多组输入
{
int i=0;
build(1,1,N);//build()用于线段树的初始化,返回值为空,参数需要线段树的根节点(id=1)以及线段树的总长度,我们要在这个函数里面输入我们的初始值哦,也就是每一个叶子节点
while(Q--)
{
char order[2];
scanf("%s",order);
if(order[0]=='Q')
{
int l,r;
scanf("%d%d",&l,&r);
printf("%I64d\n",query(1,l,r));//query()需要返回区间[l,r]内的和,参数是查询的起始节点(id=1)以及需要查询的区间[l,r]
}
if(order[0]=='C')
{
int l,r;
long long val;
scanf("%d%d%I64d",&l,&r,&val);
updata(1,l,r,val);//updata()用于数据的区间更新,无返回值,参数是查询的根节点(id=1),需要更新的区间[l,r]以及需要被维护的对象的维护方式,这里是对区间的每个数都加上val
}
}
}
return 0;
}
线段树的初始化函数:
//build()用于线段树的初始化,返回值为空,参数需要线段树的根节点(id)以及线段树的总长度,我们要在这个函数里面输入我们的初始值哦,也就是每一个叶子节点
void build(int id,int l,int r)
{
tr[id].left=l;
tr[id].right=r;
tr[id].delay=0;//初始化时每一个都不需要被标记的
if(l==r)
scanf("%I64d",&tr[id].sum);//递归到叶子节点
else
{
int mid=(l+r)/2;
build(id*2,l,mid);//建立左子树
build(id*2+1,mid+1,r);//建立右子树
tr[id].sum=tr[id*2].sum+tr[id*2+1].sum;//每次记得更新父节点的sum值哦
}
}
线段树数据区间更新函数:
//updata()用于数据的区间更新,无返回值,参数是查询的根节点(id),需要更新的区间[l,r]以及需要被维护的对象的维护方式,这里是对区间的每个数都加上val
void updata(int id,int l,int r,long long val)
{
if(l<=tr[id].left&&r>=tr[id].right)//这个区间这次需要被更新
{
tr[id].delay+=val;//表示这个区间需要被更新的方式,但暂时不更新
tr[id].sum+=val*(tr[id].right-tr[id].left+1);//更新这个区间的和
}
else//这个是搜寻需要更新的区间
{
if(tr[id].delay!=0)//搜寻到这里发现这个区间的子树还没更新呢,没办法继续搜寻,所以我们先更新它的子树
{
pushdown(id);//pushdown()用于更新左右子树,无返回值,参数只需要当前的根节点(id)
tr[id].delay=0;//记得把延迟标记重新置为0哦,因为它的左右子树已经更新过了
}
//我们接着搜寻需要被更新的区间
int mid=(tr[id].left+tr[id].right)/2;
if(r<=mid)
{
updata(id*2,l,r,val);
}
else if(l>mid)
{
updata(id*2+1,l,r,val);
}
else
{
updata(id*2,l,r,val);
updata(id*2+1,l,r,val);
}
tr[id].sum=tr[id*2].sum+tr[id*2+1].sum;//每次更新,父节点也会跟着改变嘛,所以需要回溯更新父节点的的维护对象,这里是区间和
}
}
这里是查询函数:
//query()需要返回区间[l,r]内的和,参数是查询的起始节点(id)以及需要查询的区间[l,r]
long long query(int id,int l,int r)
{
if(l<=tr[id].left&&r>=tr[id].right)//这个区间包含在我们要查询的区间,所以返回它的和
{
return tr[id].sum;
}
else//搜寻我们要查询的区间
{
if(tr[id].delay!=0)//搜寻到这里发现之前被标记过,然而我们要继续搜寻它的子树,所以我们需要先把它的子树更新
{
pushdown(id);
tr[id].delay=0;
}
int mid=(tr[id].left+tr[id].right)/2;
if(r<=mid)
return query(id*2,l,r);
else if(l>mid)
return query(id*2+1,l,r);
else
{
return query(id*2,l,r)+query(id*2+1,l,r);//两个子树都需要被搜寻所以两个子树的返回值都需要加起来
}
}
}
最后一个需要实现的函数:
//pushdown()用于更新左右子树,无返回值,参数只需要当前的根节点(id)
void pushdown(int id)
{
//把延迟标记传递给左右子树
tr[id*2].delay+=tr[id].delay;
tr[id*2+1].delay+=tr[id].delay;
//维护左右子树的维护对象,这里是维护区间和
tr[id*2].sum+=tr[id].delay*(tr[id*2].right-tr[id*2].left+1);
tr[id*2+1].sum+=tr[id].delay*(tr[id*2+1].right-tr[id*2+1].left+1);
}
这样整个题就完全解决了呢!
时空复杂度就像这样:
Memory | Time | Lenth |
---|---|---|
6556(kb) | 2657(ms) | 3818(Bytes) |
感觉时空复杂度还能降低,但是进一步的优化我却没什么思路,希望那位大佬看到后可以指教一下。
不知道大家对我的风格还习惯吗?写得不好,欢迎各位大佬们来指点我的不足,如果刚入坑的小伙伴们觉得还有不理解的地方,也请指出来,在能力范围内,我很乐意为你们解答。