HDU 3468：A Simple Problem with Integers（线段树+延迟标记）

A Simple Problem with Integers

Case Time Limit: 2000MS

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>

using namespace std;

const int maxn = 1e5+;

typedef long long ll;

struct node {
    int l, r;
    ll sum;
}tree[maxn << ];

int n, m;
ll arr[maxn];
ll lazy[maxn << ];     //懒惰数组

void pushup(int root) {
    tree[root].sum = tree[root << ].sum + tree[root <<  | ].sum;
}

void build(int root, int l ,int r) {
    tree[root].l = l;
    tree[root].r = r;
    lazy[root] = ;
    if(l == r) {
        tree[root].sum = arr[l];
        return;
    }
    int mid = (l + r) >> ;
    build(root << , l, mid);
    build(root <<  | , mid + , r);
    pushup(root);
}

void spread(int root) {
    if(lazy[root]) {        //判断延迟标记是否存在
        lazy[root << ] += lazy[root];          //左子树下传延迟标记
        lazy[root <<  | ] += lazy[root];      //右子树下传延迟标记
        tree[root << ].sum += lazy[root] * (tree[root << ].r - tree[root << ].l + );        //更新左结点信息
        tree[root <<  | ].sum += lazy[root] * (tree[root <<  | ].r - tree[root <<  | ].l + );       //更新右结点信息
        lazy[root] = ;     //清除延迟标记
    }
}

void update(int root, int x, int y, ll val) {
    int l = tree[root].l;
    int r = tree[root].r;
    if(x <= l && r <= y) {
        tree[root].sum += (r - l + ) * val;
        lazy[root] += val;      //添加延迟标记
        return;
    }
    spread(root);       //下传延迟标记
    int mid = (l + r) >> ;
    if(x <= mid) {
        update(root << , x, y, val);
    }
    if(y > mid) {
        update(root <<  | , x, y, val);
    }
    pushup(root);
}

ll query(int root, int x, int y) {
    int l = tree[root].l;
    int r = tree[root].r;
    if(x <= l && r <= y) {      //完全覆盖
        return tree[root].sum;
    }
    spread(root);       //下传延迟标记
    ll res = ;
    int mid = (l + r) >> ;
    if(x <= mid) {
        res += query(root << , x, y);
    }
    if(y > mid) {
        res += query(root <<  | , x, y);
    }
    return res;
}

int main() {
    while(~scanf("%d %d", &n, &m)) {
        for(int i = ; i <= n; i++) {
            scanf("%lld", &arr[i]);
        }
        build(, , n);
        while(m--) {
            char op[];
            int l, r;
            scanf("%s", op);
            if(op[] == 'Q') {
                scanf("%d %d", &l, &r);
                printf("%lld\n", query(, l, r));
            } else {
                ll val;
                scanf("%d %d %lld", &l, &r, &val);
                update(, l, r, val);
            }
        }
    }
    return ;
}