hdu 4348 线段树离线处理

啊！！！自己现在都想不清自己是怎么AC的了。。。

应该说是讲不清~反正就是建立一棵时间树，然后每一个时间点对应的都是一个操作，每一个操作都是由前一个操作更新过来的。其实就可以转换成一棵时间树，根节点是0时刻的，接下来的节点个时刻就等于是该节点的深度。

每处理一个操作“C”，就应该将该操作所对应的时间点上的操作全部完成，并记录下来；

在处理B操作的时候，可以直接回溯回去，将原本的"C l r d" 变成"C l r -d"就可以了，因为这样的一个操作最多被执行两次，时间复杂度只是常熟级的改变，因此不会影响结果。

话说那1010的解题报告。。。- - 




#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<iostream>
#include<algorithm>
#include<vector>
#include<map>
using namespace std;
typedef __int64 LL;
#define M 1000050

struct question {
    char c;
    int l, r, t;
    LL d;
    int cur;
    int pre, next;
    bool flag;
    LL ans;
} pnt[M];
int link[M];

struct {
    int l, r;
    LL data, tmp;
} seg[ M * 4];
LL aa[M];
int head[M];

void init(int l, int r, int id = 1) {
    seg[id].l = l;
    seg[id].r = r;
    seg[id].data = aa[l];
    seg[id].tmp = 0;
    if (l == r)return;
    int mid = (l + r) / 2;
    init(l, mid, id * 2);
    init(mid + 1, r, id * 2 + 1);
    seg[id].data = seg[id * 2].data + seg[id * 2 + 1].data;
}

void update(int l, int r, LL data, int id = 1) {
    seg[id].data += data * (r - l + 1);
    if (seg[id].l == l && seg[id].r == r) {
        seg[id].tmp += data;
        return;
    }
    int mid = (seg[id].l + seg[id].r) / 2;
    if (r <= mid)update(l, r, data, id * 2);
    else if (l > mid)update(l, r, data, id * 2 + 1);
    else {
        update(l, mid, data, id * 2);
        update(mid + 1, r, data, id * 2 + 1);
    }
}

void refresh(int id) {
    if (seg[id].tmp) {
        LL &cc = seg[id].tmp;
        if (seg[id].l != seg[id].r) {
            seg[id * 2].tmp += cc;
            seg[id * 2 + 1].tmp += cc;
            seg[id * 2].data += cc * (seg[id * 2].r - seg[id * 2].l + 1);
            seg[id * 2 + 1].data += cc * (seg[id * 2 + 1].r - seg[id * 2 + 1].l + 1);
        }
        cc = 0;
    }
}

LL query(int l, int r, int id = 1) {
    refresh(id);
    if (seg[id].l == l && seg[id].r == r) {
        return seg[id].data;
    }
    int mid = (seg[id].l + seg[id].r) / 2;
    if (r <= mid)return query(l, r, id * 2);
    else if (l > mid)return query(l, r, id * 2 + 1);
    return query(l, mid, id * 2) + query(mid + 1, r, id * 2 + 1);
}

int main() {
    int n, m, i, j;
    while (scanf("%d%d", &n, &m) != EOF) {
        for (i = 1; i <= n; i++) {
            scanf("%I64d", &aa[i]);
        }
        init(1, n, 1);
        int time = 0, prec = 0;
        // memset(head, -1, sizeof (head));
        head[0] = -1;
        link[0] = 0;
        for (i = 1; i <= m; i++) {
            char str[10];
            scanf("%s", str);
            pnt[i].c = str[0];
            if (str[0] == 'C') {
                scanf("%d%d%I64d", &pnt[i].l, &pnt[i].r, &pnt[i].d);
                head[i] = -1;
                pnt[i].flag = true;
                time++;
                pnt[i].cur = time;
                link[time] = i;
                pnt[i].pre = prec;
                prec = i;
            } else if (str[0] == 'Q') {
                scanf("%d%d", &pnt[i].l, &pnt[i].r);
            } else if (str[0] == 'H') {
                scanf("%d%d%d", &pnt[i].l, &pnt[i].r, &pnt[i].t);
                j = link[pnt[i].t];
                pnt[i].next = head[j];
                head[j] = i;
            } else if (str[0] == 'B') {
                scanf("%d", &pnt[i].t);
                time = pnt[i].t;
                pnt[i].cur = link[time];
                prec = pnt[i].cur;
            }
        }
        int cur = 0;
        for (i = head[0]; i != -1; i = pnt[i].next) {
            pnt[i].ans = query(pnt[i].l, pnt[i].r);
        }
        for (i = 1; i <= m; i++) {
            if (pnt[i].c == 'C') {
                update(pnt[i].l, pnt[i].r, pnt[i].d);
                for (j = head[i]; j != -1; j = pnt[j].next) {
                    pnt[j].ans = query(pnt[j].l, pnt[j].r);
                }
                cur = i;
            } else if (pnt[i].c == 'Q') {
                printf("%I64d\n", query(pnt[i].l, pnt[i].r));
            } else if (pnt[i].c == 'H') {
                printf("%I64d\n", pnt[i].ans);
            } else {
                while (cur != pnt[i].cur) {
                    update(pnt[cur].l, pnt[cur].r, -1 * pnt[cur].d);
                    cur = pnt[cur].pre;
                }
            }
        }
    }
    return 0;
}