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

#include<iostream>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<algorithm>
#include<stack>
#include<queue>
#include<map>
#define lt n<<1
#define rt n<<1|1
using namespace std;
typedef long long ll;
const int N = 1e6+5;
const int inf = 0x3f3f3f3f;
struct node
{
    int ltree, rtree;
    ll sum, lazy;
} tree[4*N];
int n, q, a[N];

void pushdown(int n)
{
    tree[lt].sum += tree[n].lazy * (tree[lt].rtree - tree[lt].ltree + 1);
    tree[rt].sum += tree[n].lazy * (tree[rt].rtree - tree[rt].ltree + 1);
    tree[lt].lazy += tree[n].lazy, tree[rt].lazy += tree[n].lazy;
    tree[n].lazy = 0;
}

void build(int l, int r, int n)
{
    tree[n].ltree = l, tree[n].rtree = r;
    tree[n].lazy = 0;
    if(l == r)
    {
        tree[n].sum = a[l];
        return ;
    }
    int mid = (l + r)>>1;
    build(l, mid, lt);
    build(mid+1, r, rt);
    tree[n].sum = tree[lt].sum + tree[rt].sum;
}

ll query(int l, int r, int n)
{
    int L = tree[n].ltree, R = tree[n].rtree;
    if(tree[n].lazy)
    {
        pushdown(n);
    }
    if(l <= L && r >= R)
    {
        return tree[n].sum;
    }
    int mid = (L + R)>>1;
    if(r <= mid)
    {
        return query(l, r, lt);
    }
    else if(l > mid)
    {
        return query(l, r, rt);
    }
    else
    {
        return query(l, mid, lt) + query(mid+1, r, rt);
    }
}

void uptade(int l, int r, int n, int num)
{
    int L = tree[n].ltree, R = tree[n].rtree;
    if(L == l && R == r)
    {
//        cout << l << r << endl;
        tree[n].sum += (R - L + 1)*num;
        tree[n].lazy += num;
        return ;
    }
    if(tree[n].lazy)
    {
        pushdown(n);
    }
    int mid = (L + R)>>1;
    if(mid >= r)
    {
        uptade(l, r, lt, num);
    }
    else if(mid < l)
    {
        uptade(l, r, rt, num);
    }
    else
    {
        uptade(l, mid, lt, num);
        uptade(mid+1, r, rt, num);
    }
    tree[n].sum = tree[lt].sum + tree[rt].sum;
}


int main()
{
    cin >> n >> q;
    for(int i = 1; i <= n; i++)
    {
        cin >> a[i];
    }
    build(1, n, 1);
    char c;
    while(q--)
    {
        cin >> c;
        if(c == 'Q')
        {
            int a, b;
            cin >> a >> b;
            cout << query(a, b, 1) << endl;
        }
        else
        {
            int a, b, c;
            cin >> a >> b >> c;
            uptade(a, b, 1, c);
        }
    }
    return 0;
}