线段树入门--A Simple Problem with Integers（POJ-3468）

A Simple Problem with Integers

You have N integers, A1, A2, … , AN. 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 A1, A2, … , AN. -1000000000 ≤ Ai ≤ 1000000000.
Each of the next Q lines represents an operation.
“C a b c” means adding c to each of Aa, Aa+1, … , Ab. -10000 ≤ c ≤ 10000.
“Q a b” means querying the sum of Aa, Aa+1, … , Ab.

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
4
55
9
15
Hint
The sums may exceed the range of 32-bit integers.

题意很好理解，线段树的基本操作，区间求和以及区间修改，不过此题必须用懒惰标记才能够不被T

#include <iostream>
#define ll long long
using namespace std;
const int maxn=100009;
ll a[maxn], d[maxn*4],b[maxn*4];
void geter(int s,int t ,int p){
    if(s==t){
        d[p]=a[s];
        return ;
    }
    int m=(s+t)>>1;
    geter(s,m,p<<1);geter(m+1,t,p<<1|1);
    d[p]=d[p<<1]+d[p<<1|1];
}
ll sum(int l,int r,int s,int t,int p){
    if(l<=s&&t<=r){
        return d[p];
    }
    ll sum1=0;int m=(s+t)>>1;
    if(b[p]){
        d[p<<1]+=b[p]*(m-s+1);d[p<<1|1]+=b[p]*(t-m);
        b[p<<1]+=b[p];b[p<<1|1]+=b[p];
        b[p]=0;
    }
    if(l<=m){
        sum1=sum(l,r,s,m,p<<1);
    }
    if(r>m)sum1+=sum(l,r,m+1,t,p<<1|1);
    return sum1;
}
void jia(int l,int r,int s,int t,int p,ll c){

    if(l<=s&&t<=r){
        d[p]+=c*(t-s+1);b[p]+=c;return;
    }
    int m=(s+t)>>1;
    if(b[p]&&s!=t){
        d[p<<1]+=(m-s+1)*b[p];d[p<<1|1]+=(t-m)*b[p];
        b[p<<1]+=b[p];b[p<<1|1]+=b[p];
        b[p]=0;
    }
    if(l<=m)jia(l,r,s,m,p<<1,c);
    if(r>m)jia(l,r,m+1,t,p<<1|1,c);
    d[p]=d[p<<1]+d[p<<1|1];
}
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    int n,q;
    cin>>n>>q;
    for(int i=1;i<=n;++i){
        cin>>a[i];
    }
    geter(1,n,1);
    while(q--){
        char s;int x,y;ll z;
        cin>>s;
        if(s=='Q'){
            cin>>x>>y;
            cout<<sum(x,y,1,n,1)<<endl;
        }
        else {
            cin>>x>>y>>z;
            jia(x,y,1,n,1,z);
        }
    }
return 0;
}

这里介绍加入懒惰标记的两类基本操作

区间修改：

void update(int l, int r, int c, int s, int t, int p) {
  // [l,r] 为修改区间,c 为被修改的元素的变化量,[s,t] 为当前节点包含的区间,p
  // 为当前节点的编号
  if (l <= s && t <= r) {
    d[p] += (t - s + 1) * c, b[p] += c;
    return;
  }  // 当前区间为修改区间的子集时直接修改当前节点的值,然后打标记,结束修改
  int m = (s + t) / 2;
  if (b[p] && s != t) {
    // 如果当前节点的懒标记非空,则更新当前节点两个子节点的值和懒标记值
    d[p * 2] += b[p] * (m - s + 1), d[p * 2 + 1] += b[p] * (t - m);
    b[p * 2] += b[p], b[p * 2 + 1] += b[p];  // 将标记下传给子节点
    b[p] = 0;                                // 清空当前节点的标记
  }
  if (l <= m) update(l, r, c, s, m, p * 2);
  if (r > m) update(l, r, c, m + 1, t, p * 2 + 1);
  d[p] = d[p * 2] + d[p * 2 + 1];
}

区间求和：

int getsum(int l, int r, int s, int t, int p) {
  // [l,r] 为修改区间,[s,t] 为当前节点包含的区间,p
  // 为当前节点的编号
  if (l <= s && t <= r) return d[p];
  // 当前区间为询问区间的子集时直接返回当前区间的和
  int m = (s + t) / 2;
  if (b[p]) {
    // 如果当前节点的懒标记非空,则更新当前节点两个子节点的值和懒标记值
    d[p * 2] += b[p] * (m - s + 1), d[p * 2 + 1] += b[p] * (t - m),
        b[p * 2] += b[p], b[p * 2 + 1] += b[p];  // 将标记下传给子节点
    b[p] = 0;                                    // 清空当前节点的标记
  }
  int sum = 0;
  if (l <= m) sum = getsum(l, r, s, m, p * 2);
  if (r > m) sum += getsum(l, r, m + 1, t, p * 2 + 1);
  return sum;
}

如果要是替换某个值而不是增加的话：

void update(int l, int r, int c, int s, int t, int p) {
  if (l <= s && t <= r) {
    d[p] = (t - s + 1) * c, b[p] = c;
    return;
  }
  int m = (s + t) / 2;
  if (b[p]) {
    d[p * 2] = b[p] * (m - s + 1), d[p * 2 + 1] = b[p] * (t - m),
          b[p * 2] = b[p * 2 + 1] = b[p];
    b[p] = 0;
  }
  if (l <= m) update(l, r, c, s, m, p * 2);
  if (r > m) update(l, r, c, m + 1, t, p * 2 + 1);
  d[p] = d[p * 2] + d[p * 2 + 1];
}
int getsum(int l, int r, int s, int t, int p) {
  if (l <= s && t <= r) return d[p];
  int m = (s + t) / 2;
  if (b[p]) {
    d[p * 2] = b[p] * (m - s + 1), d[p * 2 + 1] = b[p] * (t - m),
          b[p * 2] = b[p * 2 + 1] = b[p];
    b[p] = 0;
  }
  int sum = 0;
  if (l <= m) sum = getsum(l, r, s, m, p * 2);
  if (r > m) sum += getsum(l, r, m + 1, t, p * 2 + 1);
  return sum;
}

其实还可以将操作中的*2变成移位运算符<<1将操作中的 *2+1变成<<2|1;进一步增加运算速度；
关于懒惰标记，很好理解，不过基本操作的完成还是需要进一步理解，推荐先理解不带懒惰标记的操作之后再学习带懒惰标记的操作；