A Simple Problem with Integers

最新推荐文章于 2022-12-03 10:29:02 发布

原创最新推荐文章于 2022-12-03 10:29:02 发布 · 置顶 · 480 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#线段树+区间更新

ACM-线段树专栏收录该内容

4 篇文章

订阅专栏

本文介绍了一种利用线段树解决区间更新和查询问题的方法。通过延迟更新机制提高效率，实现了对序列进行区间加法操作及求区间和的功能。

线段树之区间求和

这是我的第一篇博客，希望大家能看的清楚明白。
先声明一下我的代码风格吧！我个人喜欢一般先把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);
}