POJ3468 A Simple Problem with Integers（区间更新）

最新推荐文章于 2022-12-09 12:45:57 发布

BorntoDo

最新推荐文章于 2022-12-09 12:45:57 发布

阅读量254

点赞数

分类专栏： poj 文章标签：线段树

本文链接：https://blog.csdn.net/BorntoDo/article/details/69221547

版权

poj 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

A Simple Problem with Integers

Time Limit: 5000MS		Memory Limit: 131072K
Total Submissions: 106587		Accepted: 33254
Case Time Limit: 2000MS

Description

You have N integers, A₁, A₂, ... , A_N. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The other is to ask for the sum of numbers in a given interval.

Input

The first line contains two numbers N and Q. 1 ≤ N,Q ≤ 100000.
The second line contains N numbers, the initial values of A₁, A₂, ... , A_N. -1000000000 ≤ A_i ≤ 1000000000.
Each of the next Q lines represents an operation.
"C a b c" means adding c to each of A_a, A_a₊₁, ... , A_b. -10000 ≤ c ≤ 10000.
"Q a b" means querying the sum of A_a, A_a₊₁, ... , A_b.

Output

You need to answer all Q commands in order. One answer in a line.

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

Hint

The sums may exceed the range of 32-bit integers.

线段树的更新分为区间更新和单点更新，单点更新容易理解，这里给大家详细说明一下区间更新。
所谓区间更新，我们对一整段的数进行更新操作时，如果继续单点更新会非常复杂，但是我们对此区间的数修改一下就能得到我们想要的结果。牵一发动全身，我们对该区间修改完成后，对子节点也要进行修改，我们并不立刻执行这个操作，否则就和单点操作一样了，我们将这个向下的操作pushdown放在查询操作中，并且用lazy数组标记，lazy标记的是该区间的所有子节点的区间都要修改，这就是延迟操作。
更新操作

void update(int l,int r,int rt,int ll,int rr,int x){
    if(ll<=l&&rr>=r){//当前的区间包含在要修改的区间范围内时，进行修改
        t[rt] += (r-l+1)*x;
        lazy[rt] += x;//该区间被标记
        return;
    }
    pushdown(rt,r-l+1);//向下进行标记
    int mid = (l+r)>>1;
    if(ll<=mid)
        update(lson,ll,rr,x);
    if(rr>mid)
        update(rson,ll,rr,x);
    t[rt] = t[rt<<1]+t[rt<<1|1];
}

在这里可能会有疑问，如果一个区间被连续修改好几次，我们怎么记录好几次的修改过程呢？其实我们用lazy数组就能解决这个问题，我们在进行pushdown操作的时候，将这个标记向下进行延伸，lazy数组是最终保存的是对该区间所有操作后的最终结果。
延迟标记

void pushdown(int rt,int len){
    if(lazy[rt]){
        lazy[rt<<1]+=lazy[rt];
        lazy[rt<<1|1]+=lazy[rt];
        t[rt<<1] += lazy[rt]*(len-(len>>1));
        t[rt<<1|1] += lazy[rt]*(len>>1);
        lazy[rt]=0;
    }
}

我们在查询操作的时候进行更多的pushdown操作，每次查询到的区间如果不是我们想要的，但是这个区间被标记过，那么顺手牵羊，就将这个区间一起更改，如果是我们想要的区间，我们将此区间的结果返回即可。

long long int query(int l,int r,int rt,int ll,int rr){
    if(ll<=l&&rr>=r){
        return t[rt];
    }
    pushdown(rt,r-l+1);
    int mid = (l+r)>>1;
    long long int ans = 0;
    if(ll<=mid)
        ans+=query(lson,ll,rr);
    if(rr>mid)
        ans+=query(rson,ll,rr);
    return ans;
}

这就是区间更新，区间更新的最重要一点就是延迟操作，去掉延迟操作，区间更新和单点更新大同小异。下面附上完整代码

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
using namespace std;
long long int t[100010<<2];
long long int lazy[100010<<2];//延迟标记数组 
long long int a[100010];
int n,m;
void b(int l,int r,int rt){
    if(l==r){
        t[rt] = a[l];
        return;
    }
    int mid = (l+r)>>1;
    b(lson);
    b(rson);
    t[rt] = t[rt<<1]+t[rt<<1|1];
}
void pushdown(int rt,int len){
    if(lazy[rt]){
        lazy[rt<<1]+=lazy[rt];
        lazy[rt<<1|1]+=lazy[rt];
        t[rt<<1] += lazy[rt]*(len-(len>>1));
        t[rt<<1|1] += lazy[rt]*(len>>1);
        lazy[rt]=0;
    }
}
void update(int l,int r,int rt,int ll,int rr,int x){
    if(ll<=l&&rr>=r){
        t[rt] += (r-l+1)*x;
        lazy[rt] += x;
        return;
    }
    pushdown(rt,r-l+1);
    int mid = (l+r)>>1;
    if(ll<=mid)
        update(lson,ll,rr,x);
    if(rr>mid)
        update(rson,ll,rr,x);
    t[rt] = t[rt<<1]+t[rt<<1|1];
}
long long int query(int l,int r,int rt,int ll,int rr){
    if(ll<=l&&rr>=r){
        return t[rt];
    }
    pushdown(rt,r-l+1);
    int mid = (l+r)>>1;
    long long int ans = 0;
    if(ll<=mid)
        ans+=query(lson,ll,rr);
    if(rr>mid)
        ans+=query(rson,ll,rr);
    return ans;
}
int main()
{
    cin>>n>>m;
    char c[2];
    for(int i = 1;i <= n;i++)
        scanf("%I64d",&a[i]);
    b(1,n,1);
    while(m--){
        int ll,rr,x;
        scanf("%s%d%d",c,&ll,&rr);
        if(c[0]=='C'){
            scanf("%d",&x);
            update(1,n,1,ll,rr,x);
        }
        else {
            printf("%I64d\n",query(1,n,1,ll,rr));
        }
    }
    return 0;
}