A Simple Problem with Integers POJ - 3468 (Segment Tree Template)

A Simple Problem with Integers

POJ - 3468

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+1, ... , A_b. -10000 ≤ c ≤ 10000.
"Q a b" means querying the sum of A_a, A_a+1, ... , 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

4
55
9
15

Hint

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

Line segment tree update query template
code:

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define MAX 100000
#define ll long long
#define L rt<<1
#define R rt<<1|1
struct node{
    int l, r;
    ll sum;
    ll lazy; //lazy marker
    int length;//Interval length
}Tree[MAX<<2];

void PushUp(int rt){
    Tree[rt].sum = Tree[L].sum + Tree[R].sum;
}

void PushDown(int rt){
    if(Tree[rt].lazy){
        Tree[L].sum = Tree[L].sum + Tree[rt].lazy * Tree[L].length;
        Tree[R].sum = Tree[R].sum + Tree[rt].lazy * Tree[R].length;
        Tree[L].lazy += Tree[rt].lazy;
        Tree[R].lazy += Tree[rt].lazy;
        Tree[rt].lazy = 0;
    }
}

void Build(int rt,int l,int r){
    Tree[rt].l = l;
    Tree[rt].r = r;
    Tree[rt].lazy = 0;
    Tree[rt].length = r - l + 1;
    if(l == r){
        scanf("%lld",&Tree[rt].sum);
        return;
    }
    int mid = l + r >> 1;
    Build(L,l,mid);
    Build(R,mid+1,r);
    PushUp(rt);
}

void UpDate(int rt,int l,int r,int lazy){
    if(Tree[rt].l == l && Tree[rt].r == r){
        Tree[rt].sum += Tree[rt].length * lazy;
        Tree[rt].lazy += lazy;
        return;
    }
    PushDown(rt);
    int mid = Tree[rt].l + Tree[rt].r >> 1;
    if(mid >= r)
        UpDate(L,l,r,lazy);
    else if(l > mid)
        UpDate(R,l,r,lazy);
    else{
        UpDate(L,l,mid,lazy);
        UpDate(R,mid+1,r,lazy);
    }
    PushUp(rt);
}

ll Query(int rt,int l,int r){
    if(Tree[rt].l == l && Tree[rt].r == r)
        return Tree[rt].sum;
    PushDown(rt);
    int mid = Tree[rt].l + Tree[rt].r >> 1;
    if(mid >= r)
        return Query(L,l,r);
    else if(l > mid)
        return Query(R,l,r);
    else{
        return Query(L,l,mid) + Query(R,mid+1,r);
    }
}
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    Build(1,1,n);
    int x,y,z;
    char op[3];
    while(m--){
        scanf("%s",op);
        if (at [0] == 'C') {
            scanf("%d%d%d",&x,&y,&z);
            UpDate(1,x,y,z);
        }
        else{
            scanf("%d%d",&x,&y);
            printf("%lld\n",Query(1,x,y));
        }
    }
    return 0;
}