A Simple Problem with Integers POJ

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.

 

题意：有n个整数，你需要执行两种操作 第一种：Q a b 。表示查询从a到b的所有数的和，第二种：C a b c 。表示把从a到b的所有数都加上c包括a和b。你需要按顺序给出所有查询的语句。

输入：第一行n ,q,来表示有n个数，q表示有多少个语句1<=n,q<=100000.第二行为n个数的初始数值：A1,A2,A3,,,,An,-100000000<=Ai<=100000000.接下来是q个查询语句。注意结果的总和可能超过32为整数

 

思路：线段树的模板，用到了区间加和，懒惰标记，和区间求和，比较注意的 是数比较大，所以我用的是longlong，

 

代码：

#include <cstdio>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <set>
#include <sstream>
#include <iostream>
#define mod 998244353
#define eps 1e-6
#define ll long long
#define INF 0x3f3f3f3f
using namespace std;

struct node
{
    //l表示左边，r表示右边，sum表示该线段的值
    ll l,r,sum;
    ll lazy;
};
node no[600000];
//存放每个点的值
ll number[100000];

inline void update(int k)
{
    //用左右线段的值更新该线段的值
    no[k].sum=no[k*2].sum+no[k*2+1].sum;
}
//初始化
//k表示当前节点的编号，l表示当前区间的左边界，r表示当前区间的右边界
void build(ll k,ll l,ll r)
{
    no[k].lazy=0;
    no[k].l=l;
    no[k].r=r;
    //如果递归到最低点
    if(l==r)
    {
        //赋值并记录该点对应的节点编号
        no[k].sum=number[l];
        return ;
    }
    //对半分
    ll mid=(l+r)/2;
    //递归到左线段
    build(k*2,l,mid);
    //递归到右线段
    build(k*2+1,mid+1,r);
    update(k);
}
void pushdown(ll k)
{
    //如果节点k已经是叶节点了，没有子节点，那么标记就不用下传，直接删除就可以了
    if(no[k].l==no[k].r)
    {
        no[k].lazy=0;
        return ;
    }
    //给k的子节点重新赋值
    no[k*2].sum+=(no[k*2].r-no[k].l+1)*no[k].lazy;
    no[k*2+1].sum+=(no[k*2+1].r-no[k*2+1].l+1)*no[k].lazy;
    //下传点k的标记
    no[k*2].lazy+=no[k].lazy;
    no[k*2+1].lazy+=no[k].lazy;
    //清空点k的标记
    no[k].lazy=0;
}

void change(ll k,ll l,ll r,ll x)
{
        //如果当前节点被打上了懒惰标记，那么就把这个标记下传，
    if(no[k].lazy)
    {
        pushdown(k);
    }

    if(no[k].l==l&&no[k].r==r)
    {
        no[k].sum+=(r-l+1)*x;
        no[k].lazy+=x;
        return ;
    }

    ll mid = (no[k].l+no[k].r)/2;
    if(r<=mid)
    {
        change(k*2,l,r,x);
    }
    else if(l>mid)
    {
        change(k*2+1,l,r,x);
    }
    else
    {
        change(k*2,l,mid,x);
        change(k*2+1,mid+1,r,x);
    }
    update(k);
}

//查询指定区间内的所有的和
//k表示当前节点的编号，l表示当前区间的左边界，r表示当前区间的右边界
ll query(ll k,ll l,ll r)
{
    //如果当前区间就是询问区间，完全重合，那么显然可以直接返回
    if(no[k].l==l&&no[k].r==r)
    {
        return no[k].sum;
    }
    //如果当前节点被打上了懒惰标记，那么就把这个标记下传，
    if(no[k].lazy)
    {
        pushdown(k);
    }
    //取中值
    ll mid = (no[k].l+no[k].r)/2;
    //如果询问区间包含在左子区间中
    if(r<=mid)
    {
        return query(k*2,l,r);
    }
    else if(l>mid)//如果询问区间包含在右子区间中
    {
        return query(k*2+1,l,r);
    }
    else//如果询问区间跨越两个子区间
    {
        return query(k*2,l,mid)+query(k*2+1,mid+1,r);
    }
}

int main()
{
    ll m,n;
    scanf("%I64d %I64d",&m,&n);
    for(ll i=1;i<=m;i++)
    {
        scanf("%I64d",&number[i]);
    }
    build(1,1,m);
    char str[2];
    ll a,b,c;
    while(n--)
    {
        cin>>str;
        if(str[0]=='Q')
        {
            scanf("%I64d %I64d",&a,&b);
            printf("%I64d
",query(1,a,b));
        }
        else if(str[0]=='C')
        {
            scanf("%I64d %I64d %I64d",&a,&b,&c);
            change(1,a,b,c);
        }
    }  
}