To the moon HDU - 4348 （主席树，区间修改）

Background 
To The Moon is a independent game released in November 2011, it is a role-playing adventure game powered by RPG Maker. 
The premise of To The Moon is based around a technology that allows us to permanently reconstruct the memory on dying man. In this problem, we'll give you a chance, to implement the logic behind the scene.

You‘ve been given N integers A _[1], A _[2],..., A _[N]. On these integers, you need to implement the following operations: 
1. C l r d: Adding a constant d for every {A _i | l <= i <= r}, and increase the time stamp by 1, this is the only operation that will cause the time stamp increase. 
2. Q l r: Querying the current sum of {A _i | l <= i <= r}. 
3. H l r t: Querying a history sum of {A _i | l <= i <= r} in time t. 
4. B t: Back to time t. And once you decide return to a past, you can never be access to a forward edition anymore. 
.. N, M ≤ 10 ⁵, |A _[i]| ≤ 10 ⁹, 1 ≤ l ≤ r ≤ N, |d| ≤ 10 ⁴ .. the system start from time 0, and the first modification is in time 1, t ≥ 0, and won't introduce you to a future state.

Input

n m 

A ₁ A ₂ ... A _n 
... (here following the m operations. )

Output

... (for each query, simply print the result. )

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

2 4
0 0
C 1 1 1
C 2 2 -1
Q 1 2
H 1 2 1

Sample Output

4
55
9
15

0
1

给出 n 个数，m次操作，操作一共分成 4 种
1、[l, r]内的值增加 d， 并且 time + 1
2、查询当前 time 时 [l, r]内的和
3、查询time = t 时 [l, r]内的和
4、把 time 退回到 t
然后对于2、3操作，输出对应的答案。
因为有4操作，所以要用主席树来保留每一个 time 的线段树。
对于区间修改操作，像线段树一样去更新，对于区间的sum，直接更新当前区间内的sum值，但是 update 的时候并不能保证 update 到的区间都被给出的区间所包含，所以需要用(min(r, pr) - max(l, pl) + 1)来确定有几个要更新的点。对于lazy，只有当 update 到的区间完全被给出的区间所包含的时候，才更新 lazy， 这样保证了 sum 不会多加， lazy 不会多标记。
对于区间查询操作，由于在之前更新的时候就已经把当前区间的 sum 求出来了，所以当某个区间完全被查询区间包含，只要直接加上这个区间的 sum 值就可以了。对于lazy，有 lazy 标记的区间，区间内的每个点都要加上 lazy 的值，所以如果我 query 到的区间有 lazy 标记，那么说明我这个区间内的每个点都应该多加 lazy ，给这个区间内需要加 lazy 的值的个数也是 (min(r, pr) - max(l, pl) + 1)

 /*
           .
          ';;;;;.
         '!;;;;;;!;`
        '!;|&#@|;;;;!:
       `;;!&####@|;;;;!:
      .;;;!&@$$%|!;;;;;;!'.`:::::'.
      '!;;;;;;;;!$@###&|;;|%!;!$|;;;;|&&;.
      :!;;;;!$@&%|;;;;;;;;;|!::!!:::;!$%;!$%`    '!%&#########@$!:.
      ;!;;!!;;;;;|$$&@##$;;;::'''''::;;;;|&|%@$|;;;;;;;;;;;;;;;;!$;
      ;|;;;;;;;;;;;;;;;;;;!%@#####&!:::;!;;;;;;;;;;!&####@%!;;;;$%`
     `!!;;;;;;;;;;!|%%|!!;::;;|@##%|$|;;;;;;;;;;;;!|%$#####%;;;%&;
     :@###&!:;;!!||%%%%%|!;;;;;||;;;;||!$&&@@%;;;;;;;|$$##$;;;%@|
     ;|::;;;;;;;;;;;;|&&$|;;!$@&$!;;;;!;;;;;;;;;;;;;;;;!%|;;;%@%.
    `!!;;;;;;;!!!!;;;;;$@@@&&&&&@$!;!%|;;;;!||!;;;;;!|%%%!;;%@|.
 %&&$!;;;;;!;;;;;;;;;;;|$&&&&&&&&&@@%!%%;!||!;;;;;;;;;;;;;$##!
 !%;;;;;;!%!:;;;;;;;;;;!$&&&&&&&&&&@##&%|||;;;!!||!;;;;;;;$&:
 ':|@###%;:;;;;;;;;;;;;!%$&&&&&&@@$!;;;;;;;!!!;;;;;%&!;;|&%.
  !@|;;;;;;;;;;;;;;;;;;|%|$&&$%&&|;;;;;;;;;;;;!;;;;;!&@@&'
   .:%#&!;;;;;;;;;;;;;;!%|$$%%&@%;;;;;;;;;;;;;;;;;;;!&@:
   .%$;;;;;;;;;;;;;;;;;;|$$$$@&|;;;;;;;;;;;;;;;;;;;;%@%.
     !&!;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;|@#;
      `%$!;;;;;;;;;;;$@|;;;;;;;;;;;;;;;;;;;;;;;;!%$@#@|.
        .|@%!;;;;;;;;;!$&%||;;;;;;;;;;;;;;;;;!%$$$$$@#|.
            ;&$!;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;%#####|.
            |##$|!;;;;;;::'':;;;;;;;;;;;;;!%$$$@#@;
           ;@&|;;;;;;;::'''''':;;;;;;;|$&@###@|`
         .%##@|;;;;:::''''''''''::;!%&##$'
       `$##@$$@@&|!!;;;:'''''::::;;;;;|&#%.
     ;&@##&$%!;;;;;;::''''''''::;!|%$@#@&@@:
      .%@&$$|;;;;;;;;;;:'''':''''::;;;%@#@@#%.
     :@##@###@$$$$$|;;:'''':;;!!;;;;;;!$#@@#$;`
      `%@$$|;;;;;;;;:'''''''::;;;;|%$$|!!&###&'
      |##&%!;;;;;::''''''''''''::;;;;;;;!$@&:`!'
     :;!@$|;;;;;;;::''''''''''':;;;;;;;;!%&@$:                 !@#$'
       |##@@&%;;;;;::''''''''':;;;;;;;!%&@#@$%:              '%%!%&;
       |&%!;;;;;;;%$!:''''''':|%!;;;;;;;;|&@%||`            '%$|!%&;
       |@%!;;!!;;;||;:'''''':;%$!;;;;!%%%&#&%$&:           .|%;:!&%`
       !@&%;;;;;;;||;;;:''::;;%$!;;;;;;;|&@%;!$;          `%&%!!$&:
       '$$|;!!!!;;||;;;;;;;;;;%%;;;;;;;|@@|!$##;         !$!;:!$&:
        |#&|;;;;;;!||;;;;;;;;!%|;;;;!$##$;;;;|%'      `%$|%%;|&$'
         |&%!;;;;;;|%;;;;;;;;$$;;;;;;|&&|!|%&&;  .:%&$!;;;:!$@!
         `%#&%!!;;;;||;;;;;!$&|;;;!%%%@&!;;;!!;;;|%!;;%@$!%@!
         !&!;;;;;;;;;||;;%&!;;;;;;;;;%@&!;;!&$;;;|&%;;;%@%`
        '%|;;;;;;;;!!|$|%&%;;;;;;;;;;|&#&|!!||!!|%$@@|'
        .!%%&%'`|$;       :|$#%|@#&;%#%.
 */
 #include <map>
 #include <set>
 #include <list>
 #include <ctime>
 #include <cmath>
 #include <stack>
 #include <queue>
 #include <string>
 #include <vector>
 #include <cstdio>
 #include <bitset>
 #include <cstdlib>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #define  lowbit(x)  x & (-x)
 #define  mes(a, b)  memset(a, b, sizeof a)
 #define  fi         first
 #define  se         second
 #define  pii        pair<int, int>
 #define  INOPEN     freopen("in.txt", "r", stdin)
 #define  OUTOPEN    freopen("out.txt", "w", stdout)

 typedef unsigned long long int ull;
 typedef long long int ll;
 const int    maxn = 1e5 + ;
 const int    maxm = 1e5 + ;
 const ll     mod  = 1e9 + ;
 const ll     INF  = 1e18 + ;
 const int    inf  = 0x3f3f3f3f;
 const double pi   = acos(-1.0);
 const double eps  = 1e-;
 using namespace std;

 int n, m;
 int cas, tol, T;

 struct Node{
     int l, r;
     ll sum, lazy;
 } node[maxn * ];
 ll a[maxn];
 int rt[maxn];

 void init() {
     tol = ;
     mes(a, );
     mes(rt, );
 }

 void pushup(int rt) {
     node[rt].sum = node[node[rt].l].sum + node[node[rt].r].sum;
 }

 void build(int l, int r, int &rt) {
     rt = ++tol;
     node[rt].sum = node[rt].lazy = ;
     if(l == r) {
         node[rt].sum = a[l];
         return ;
     }
     int mid = (l + r) >> ;
     build(l, mid, node[rt].l);
     build(mid+, r, node[rt].r);
     pushup(rt);
 }

 void update(int l, int r, int &x, int y, int pl, int pr, ll val) {
     x = ++tol;
     node[x] = node[y];
     node[x].sum += 1ll * (min(r, pr) - max(l, pl) + ) * val;
     if(pl <= l && r <= pr) {
         node[x].lazy += val;
         return ;
     }
     int mid = (l + r) >> ;
     if(pl <= mid)
         update(l, mid, node[x].l, node[y].l, pl, pr, val);
     if(pr > mid)
         update(mid+, r, node[x].r, node[y].r, pl, pr, val);
 }

 ll query(int l, int r, int pl, int pr, int rt) {
     if(pl <= l && r <= pr) {
         return node[rt].sum;
     }
     int mid = (l + r) >> ;
     ll ans = 1ll * (min(r, pr) - max(l, pl) + ) * node[rt].lazy;
     if(pl <= mid)
         ans += query(l, mid, pl, pr, node[rt].l);
     if(pr > mid)
         ans += query(mid+, r, pl, pr, node[rt].r);
     return ans;
 }

 int main() {
     while(~scanf("%d%d", &n, &m)) {
         init();
         for(int i=; i<=n; i++) {
             scanf("%lld", &a[i]);
         }
         T = ;
         build(, n, rt[T]);
         char s[];
         while(m--) {
             scanf("%s", s+);
             if(s[] == 'C') {
                 int l, r;
                 ll d;
                 scanf("%d%d%lld", &l, &r, &d);
                 T++;
                 update(, n, rt[T], rt[T-], l, r, d);
             } else if(s[] == 'Q') {
                 int l, r;
                 scanf("%d%d", &l, &r);
                 ll ans = query(, n, l, r, rt[T]);
                 printf("%lld\n", ans);
             } else if(s[] == 'H') {
                 int l, r, t;
                 scanf("%d%d%d", &l, &r, &t);
                 ll ans = query(, n, l, r, rt[t]);
                 printf("%lld\n", ans);
             } else if(s[] == 'B'){
                 int t;
                 scanf("%d", &t);
                 T = t;
             }
         }
     }
     return ;
 }