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.

题意：有n个数字，m次操作，第二行是n个数字，以下m行就是对应的操作，Q代表对后边的区间求和，C代表后边区间要加上一个数；

分析：线段树，这道题要实现区间求和与更新

Select Code

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
#define ll long long
ll a[100010];
struct Ti
{
    ll l,r,sum,lazy;
}t[100010*4];
void up(ll k)//更新子节点的父亲
{
    t[k].sum=t[k*2].sum+t[k*2+1].sum;
}
void pushdown(ll k)
{
    if(t[k].lazy)//如果被标记
    {
        t[2*k].lazy+=t[k].lazy;//这里是加上某个值，如果题意是替换，应该t[2*k].lazy=t[k].lazy
        t[2*k+1].lazy+=t[k].lazy;
        t[k*2].sum+=t[k].lazy*(t[k*2].r-t[k*2].l+1);
        t[k*2+1].sum+=t[k].lazy*(t[k*2+1].r-t[k*2+1].l+1);
        t[k].lazy=0;
    }
}
void build(ll l,ll r,ll k)//建树
{
    t[k].lazy=0;
    t[k].l=l;
    t[k].r=r;
    if(l==r)//叶子结点值等于真实输入的值
    {
        t[k].sum=a[r];
        return;
    }
    ll mid=(l+r)/2;
    build(l,mid,k*2);
    build(mid+1,r,k*2+1);
    up(k);
}
void update(ll l,ll r,ll v,ll k)//更新
{
    if(l<=t[k].l&&r>=t[k].r)//如果是真子集
    {
        t[k].sum+=v*(t[k].r-t[k].l+1);//如果是替换成某数，应该是直接等于v*(t[k].r-t[k].l+1)
        t[k].lazy+=v;//这里也是
        return;
    }
    pushdown(k);
    ll mid=(t[k].l+t[k].r)/2;
    if(l<=mid)
        update(l,r,v,k*2);
    if(r>mid)
        update(l,r,v,k*2+1);
    up(k);
}
ll query(ll l,ll r,ll k)//查询
{
    if(l<=t[k].l&&r>=t[k].r)
        return t[k].sum;
    pushdown(k);
    ll mid=(t[k].l+t[k].r)/2,ans=0;
    if(l<=mid)
        ans+=query(l,r,k*2);
    if(r>mid)
        ans+=query(l,r,k*2+1);
    return ans;
}
int main()
{
    ll n,m;
    while(~scanf("%lld%lld",&n,&m))
    {
        int i;
        for(i=1;i<=n;i++)
            scanf("%lld",&a[i]);
        build(1,n,1);
        char c;
        ll x,y,z;
        while(m--)
        {
            getchar();
            scanf("%c",&c);
            if(c=='Q')
            {
                scanf("%lld%lld",&x,&y);
                printf("%lld\n",query(x,y,1));
            }
            else
            {
                scanf("%lld%lld%lld",&x,&y,&z);
                update(x,y,z,1);
            }
        }
    }
    return 0;
}