POJ 3468 A Simple Problem with Integers(线段树区间更新区间求和)

A Simple Problem with Integers

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+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.

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <stack>
#include <algorithm>
using namespace std;
#define root 1,n,1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define lr rt<<1
#define rr rt<<1|1
typedef long long LL;
const int oo = 1e9+7;
const double PI = acos(-1.0);
const double eps = 1e-6 ;
const int N = 100010;
const int mod = 2333333;
int n , m ;
LL sum[N<<2] , lazy[N<<2] , e[N] , tot ;

void Up( int rt ) {
    sum[rt] = sum[lr] + sum[rr];
}
void Down( int l , int r , int rt ) {
    if( lazy[rt] != 0 ) {
        int mid = (l+r)>>1;
        sum[lr] += lazy[rt]*(mid-l+1) , sum[rr] += lazy[rt]*(r-mid);
        lazy[lr] += lazy[rt] , lazy[rr] += lazy[rt];
        lazy[rt] = 0 ;
    }
}
void build( int l , int r , int rt ){
    lazy[rt] = 0 ;
    if( l == r ) {
        sum[rt] = e[tot++];
        return ;
    }
    int mid = (l+r)>>1;
    build(lson),build(rson);
    Up(rt);
}
void update( int l , int r , int rt , int L , int R , LL val ) {
    if( L == l && r == R ) {
        sum[rt] += val*(r-l+1) ;
        lazy[rt] += val;
        return ;
    }
    Down( l , r , rt );
    int mid = (l+r)>>1;
    if( R <= mid ) update(lson,L,R,val);
    else if( L > mid ) update(rson,L,R,val);
    else update(lson,L,mid,val) , update(rson,mid+1,R,val);
    Up(rt);
}
LL query( int l , int r , int rt , int L , int R ) {
    if( L == l && r == R ) {
        return sum[rt];
    }
    Down(l,r,rt);
    int mid = (l+r)>>1;
    if( R <= mid ) return query(lson,L,R);
    else if( L > mid ) return query(rson,L,R);
    else return query(lson,L,mid) + query(rson,mid+1,R);
}

int main()
{
    #ifdef LOCAL
        freopen("in.txt","r",stdin);
//        freopen("out.txt","w",stdout);
    #endif // LOCAL
    char s[10]; int x , y ; LL c ;
    while( ~scanf("%d%d",&n,&m ) ) {
        tot = 0 ;
        for( int i = 0 ; i < n ; ++i ) {
            scanf("%I64d",&e[i]);
        }
        build(root);
        while(m--) {
            scanf("%s",s);
            if( s[0] == ‘Q‘ ) {
                scanf("%d%d",&x,&y);
                printf("%I64d\n",query(root,x,y));
            }
            else {
                scanf("%d%d%I64d",&x,&y,&c);
                update(root,x,y,c);
            }
        }
    }
}