线段树 （区间查询最大 区间求和 区间加）带lazy

 const int N=1e5+;

 struct Segment_tree
 {
     struct Node
     {
         int val,Max,lazy;
         int Size,son[];
         void init()
         {
             lazy=son[]=son[]=Size=val=Max=val=;
         }
     } T[N*];
     int cnt,root;

     void init(int l,int r,int *a)
     {
         cnt=;
         root=build(l,r,a);
     }

     void update(int pos)
     {
         if(T[pos].Size==)return ;
         T[pos].val=T[T[pos].son[]].val+T[T[pos].son[]].val;
         if(T[T[pos].son[]].lazy)
         {
             T[pos].val+=T[T[pos].son[]].lazy*T[T[pos].son[]].Size;
         }
         if(T[T[pos].son[]].lazy)
         {
             T[pos].val+=T[T[pos].son[]].lazy*T[T[pos].son[]].Size;
         }
         T[pos].Max=max(T[T[pos].son[]].Max+T[T[pos].son[]].lazy,T[T[pos].son[]].Max+T[T[pos].son[]].lazy);
     }

     void pushdown(int pos)
     {
         if(pos==)return ;
         if(T[pos].lazy)
         {
             if(T[pos].son[])
             {
                 int x=T[pos].son[];
                 if(T[x].Size==)
                 {
                     T[x].val+=T[pos].lazy;
                     T[x].Max+=T[pos].lazy;
                 }
                 else
                 {
                     T[x].lazy+=T[pos].lazy;
                 }
             }
             if(T[pos].son[])
             {
                 int x=T[pos].son[];
                 if(T[x].Size==)
                 {
                     T[x].val+=T[pos].lazy;
                     T[x].Max+=T[pos].lazy;
                 }
                 else
                 {
                     T[x].lazy+=T[pos].lazy;
                 }
             }
             T[pos].lazy=;
         }
     }

     int build(int l,int r,int *a)
     {
         int pos=++cnt;
         T[pos].init();
         T[pos].Size=r-l+;
         if(l==r)
         {
             T[pos].val=a[l];
             T[pos].Max=a[l];
             return pos;
         }
         int mid=(l+r)>>;
         T[pos].son[]=build(l,mid,a);
         T[pos].son[]=build(mid+,r,a);
         update(pos);
         return pos;
     }

     void add(int L,int R,int l,int r,int v,int pos=)
     {
         if(L==l&&R==r)
         {
             if(l==r)
             {
                 T[pos].val+=v;
                 T[pos].Max+=v;
             }
             else
             {
                 T[pos].lazy+=v;
             }
             return ;
         }
         int mid=(L+R)>>;
         if(r<=mid)
             add(L,mid,l,r,v,T[pos].son[]);
         else if(l>mid)
             add(mid+,R,l,r,v,T[pos].son[]);
         else
         {
             add(L,mid,l,mid,v,T[pos].son[]);
             add(mid+,R,mid+,r,v,T[pos].son[]);
         }
         update(pos);
     }

     int query_Max(int L,int R,int l,int r,int pos=)
     {
         pushdown(pos);
         update(pos);
         if(L==l&&R==r)
         {
             return T[pos].Max;
         }
         int mid=(L+R)>>;
         if(r<=mid)
             return query_Max(L,mid,l,r,T[pos].son[]);
         else if(l>mid)
             return query_Max(mid+,R,l,r,T[pos].son[]);
         else
             return max(query_Max(L,mid,l,mid,T[pos].son[]),query_Max(mid+,R,mid+,r,T[pos].son[]));
     }

     int query_Sum(int L,int R,int l,int r,int pos=)
     {
         pushdown(pos);
         update(pos);
         if(L==l&&R==r)
         {
             return T[pos].val;
         }
         int mid=(L+R)>>;
         if(r<=mid)
             return query_Sum(L,mid,l,r,T[pos].son[]);
         else if(l>mid)
             return query_Sum(mid+,R,l,r,T[pos].son[]);
         else
             return query_Sum(L,mid,l,mid,T[pos].son[])+query_Sum(mid+,R,mid+,r,T[pos].son[]);
     }

 }tree;