POJ3468(KB7-C 线段树)

A Simple Problem with Integers

Time Limit: 5000MS  Memory Limit: 131072K

Total Submissions: 108903   Accepted: 33919

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.

Source

POJ Monthly--2007.11.25, Yang Yi

 

带lazy的线段树

//2017-05-17
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define ll long long
#define mid ((st[id].l+st[id].r)>>1)
#define lson (id<<1)
#define rson ((id<<1)|1)

using namespace std;

const ll N = 100005;
ll arr[N];
struct Node{
    ll l, r, sum, lazy;
}st[N<<2];

void build(int id, int l, int r)
{
    st[id].l = l; st[id].r = r; st[id].lazy = 0;
    if(l == r){
        st[id].sum = arr[l];
        return;
    }
    build(lson, l, mid);
    build(rson, mid+1, r);
    st[id].sum = st[lson].sum+st[rson].sum;
}

void push_down(int id)
{
    if(st[id].lazy != 0){
        st[lson].lazy += st[id].lazy;
        st[rson].lazy += st[id].lazy;
        st[id].sum += (st[id].r-st[id].l+1)*st[id].lazy;
        st[id].lazy = 0;
    }
    return;
}

ll query(int id, int l, int r)
{
    if(st[id].l == l && st[id].r == r)return st[id].sum+(r-l+1)*st[id].lazy;
    push_down(id);
    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);
}

void update(int id, int l, int r, int w)
{
    if(st[id].l == l && st[id].r == r){
        st[id].lazy += w;
        return;
    }
    st[id].sum += (r-l+1)*w;
    if(r <= mid)update(lson, l, r, w);
    else if(l > mid)update(rson, l, r, w);
    else{
        update(lson, l, mid, w);
        update(rson, mid+1, r, w);
    }
}

int main()
{
    ll n, q;
    while(scanf("%lld%lld", &n, &q)!=EOF){
        for(int i = 1; i <= n; i++)
          scanf("%lld", &arr[i]);
        build(1, 1, n);
        char op[5];
        ll a, b, c;
        while(q--){
            scanf("%s", op);
            if(op[0] == 'Q'){
                scanf("%lld%lld", &a, &b);
                printf("%lld\n", query(1, a, b));
            }else if(op[0] == 'C'){
                scanf("%lld%lld%lld", &a, &b, &c);
                update(1, a, b, c);
            }
        }
    }

    return 0;
}

 

//2018-03-28

import java.util.*;
    
public class Main {

    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        
        int n, q;
        while(cin.hasNext()) {
            n = cin.nextInt();
            q = cin.nextInt();
            SegmentTree st = new SegmentTree(n);
            for(int i = 1; i <= n; i++)
                st.arr[i] = cin.nextLong();
            st.build(1, 1, n);
            char op;
            int a, b;
            long c;
            while(q-- > 0) {
                op = cin.next().charAt(0);
                if(op == 'Q') {
                    a = cin.nextInt();
                    b = cin.nextInt();
                    System.out.println(st.query(1, a, b));
                }else if(op == 'C') {
                    a = cin.nextInt();
                    b = cin.nextInt();
                    c = cin.nextLong();
                    st.updata(1, a, b, c);
                }
            }
        }
    }
}
    
class SegmentTree{
    static class Node{
        public int l, r;
        long sum, lazy;
        Node(int _l, int _r, long _sum, long _lazy){
            this.l = _l;
            this.r = _r;
            this.sum = _sum;
            this.lazy = _lazy;
        }
    }
    
    public int n;
    public long [] arr;
    public Node [] nodes;
    
    SegmentTree(int _n){
        this.n = _n;
        arr = new long[n+1];
        nodes = new Node[n<<2];
    }
    
    int lson(int id) {
        return (id<<1);
    }
    
    int rson(int id) {
        return ((id<<1)|1);
    }
    
    int mid(int id) {
        return (nodes[id].l + nodes[id].r)>>1;
    }
    void build(int id, int l, int r) {
        nodes[id] = new Node(l, r, 0, 0);
        if(l == r) {
            nodes[id].sum = arr[l];
            return;
        }
        build(lson(id), l, mid(id));
        build(rson(id), mid(id)+1, r);
        nodes[id].sum = nodes[lson(id)].sum + nodes[rson(id)].sum;
    }
    
    void pushDown(int id) {
        if(nodes[id].lazy != 0) {
            nodes[lson(id)].lazy += nodes[id].lazy;
            nodes[rson(id)].lazy += nodes[id].lazy;
            nodes[id].sum += (nodes[id].r-nodes[id].l+1)*nodes[id].lazy;
            nodes[id].lazy = 0;
        }
    }
    
    long query(int id, int l, int r) {
        if(nodes[id].l == l && nodes[id].r == r)
            return nodes[id].sum+(r-l+1)*nodes[id].lazy;
        pushDown(id);
        if(r <= mid(id))return query(lson(id), l, r);
        else if(l > mid(id))return query(rson(id), l, r);
        else return query(lson(id), l, mid(id))+query(rson(id), mid(id)+1, r);
    }
    
    void updata(int id, int l, int r, long w) {
        if(nodes[id] == null)return;
        if(nodes[id].l == l && nodes[id].r == r) {
            nodes[id].lazy += w;
            return;
        }
        nodes[id].sum += (r-l+1)*w;
        if(r <= mid(id))updata(lson(id), l, r, w);
        else if(l > mid(id))updata(rson(id), l, r, w);
        else {
            updata(lson(id), l, mid(id), w);
            updata(rson(id), mid(id)+1, r, w);
        }
    }
}