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

const int N=1e5+2;

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

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

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

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

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

    void add(int L,int R,int l,int r,int v,int pos=1)
    {
        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)>>1;
        if(r<=mid)
            add(L,mid,l,r,v,T[pos].son[0]);
        else if(l>mid)
            add(mid+1,R,l,r,v,T[pos].son[1]);
        else
        {
            add(L,mid,l,mid,v,T[pos].son[0]);
            add(mid+1,R,mid+1,r,v,T[pos].son[1]);
        }
        update(pos);
    }

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

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

}tree;