线段树-sum/max/min/区间更新

写一个板子。

 #include <cstdio>
 #include <algorithm>

 using namespace std;

 const int maxn = +;

 #define ROOT     1, 1, N
 #define lson(x)  (x<<1)
 #define rson(x)  (x<<1|1)

 struct SegmentTree{
     int l, r;
     int ma, mi, sum;
     int lazy;
     int lazy_ma, lazy_mi;
 }st[maxn << ];

 int val[maxn],N;

 void push_up(int x){
     st[x].sum = st[lson(x)].sum + st[rson(x)].sum;
     st[x].ma  = max(st[lson(x)].ma, st[rson(x)].ma);
     st[x].mi  = min(st[lson(x)].mi, st[rson(x)].mi);
 }

 void push_down(int x, int m){
     if(st[x].lazy){
         st[lson(x)].sum += (m-(m>>)) * st[x].lazy;
         st[rson(x)].sum += (m>>) * st[x].lazy;
         st[lson(x)].ma += st[x].lazy; st[lson(x)].mi += st[x].lazy;
         st[rson(x)].ma += st[x].lazy; st[rson(x)].mi += st[x].lazy;

         st[lson(x)].lazy += st[x].lazy;
         st[rson(x)].lazy += st[x].lazy;

         st[x].lazy = ;
     }
 }

 void build(int x, int l, int r){
     st[x].l = l;st[x].r = r;
     st[x].lazy = st[x].lazy_mi = st[x].lazy_ma = ;

     if(l == r){
         st[x].sum = val[l];
         st[x].ma = st[x].mi = val[l];
         return ;
     }
     int mid = (l+r)>>;
     build(lson(x), l, mid);
     build(rson(x), mid+, r);
     push_up(x);
 }

 void update(int L, int R, int c, int x,int l,int r){
     if(L <= l && R >= r){
         st[x].sum += c * (r-l+);
         st[x].ma += c;
         st[x].mi += c;
         st[x].lazy += c;
         return ;
     }
     push_down(x, r-l+);

     int mid = (l+r)>>;
     if(L <= mid) update(L, R, c, lson(x), l, mid);
     if(R > mid) update(L, R, c, rson(x), mid+, r);
     push_up(x);
 }

 int query_sum(int L, int R, int x, int l, int r){
     if(L <= l && R >= r){
         return st[x].sum;
     }
     push_down(x, r-l+);

     int mid = (l+r)>>, res = ;
     if(R <= mid)      res = query_sum(L, R, lson(x), l, mid);
     else if(L > mid) res = query_sum(L, R, rson(x), mid+, r);
     else          res = query_sum(L, R, lson(x), l, mid) + query_sum(L, R, rson(x), mid+, r);
     push_up(x);
     return res;
 }

 int query_max(int L,int R, int x, int l, int r){
     if(L <= l && R >= r){
         return st[x].ma;
     }
     push_down(x, r-l+);

     int mid = (l+r)>>, res = ;
     if(R <= mid)      res = query_max(L, R, lson(x), l, mid);
     else if(L > mid) res = query_max(L, R, rson(x), mid+, r);
     else              res = max(query_max(L, R, lson(x), l, mid), query_max(L, R, rson(x), mid+, r));
     push_up(x);
     return res;
 }

 int query_min(int L,int R, int x, int l, int r){
     if(L <= l && R >= r){
         return st[x].mi;
     }
     push_down(x, r-l+);

     int mid = (l+r)>>, res = ;
     if(R <= mid)      res = query_min(L, R, lson(x), l, mid);
     else if(L > mid) res = query_min(L, R, rson(x), mid+, r);
     else              res = min(query_min(L, R, lson(x), l, mid), query_min(L, R, rson(x), mid+, r));
     push_up(x);
     return res;
 }

 int T,M;

 int main(){
     scanf("%d", &T);
     while(T--){
         scanf("%d %d\n", &N, &M);
         for(int i=;i<=N;i++) scanf("%d", &val[i]);
         build(ROOT);

         for(int i=;i<M;i++){
             char op[];
             int l, r, c;
             scanf("%s", op);
             if(op[] == 'Q' && op[] == 'S'){
                 scanf("%d %d", &l, &r);
                 printf("%d\n", query_sum(l, r, ROOT));
             }else if(op[] == 'Q' && op[] == 'A'){
                 scanf("%d %d", &l, &r);
                 printf("%d\n", query_max(l, r, ROOT));
             }else if(op[] == 'Q' && op[] == 'I'){
                 scanf("%d %d", &l, &r);
                 printf("%d\n", query_min(l, r, ROOT));
             }else if(op[] == 'I'){
                 scanf("%d %d %d", &l, &r, &c);
                 update(l, r, c, ROOT);
             }
         }
     }
 }