uestc Another LCIS（区间更新，区间合并）

题意:

求最长上升子序列的最大长度。

两种操作：

q： 某一段区间的最长上升子序列的最大长度为多少

a： 某一段区间都加上val

解题思路:

如果单单求最长上升子序列，我们可以通过dp，或者分治的思想来求。因为此处操作多，所以上述方法不可行。

我们在线段树的结点里增加几个域:

lsum :  表示从当前结点的最左端开始的上升子序列的长度

rsum:  表示从当前结点的最右端开始的上升子序列的长度

a :       表示整体的增幅

lazy:   lazy标记，lazy>0 表示还未向下更新

la：    表示当前结点的最左端开始的上升子序列的值的增幅

ra：    表示从当前结点的最右端开始的上升子序列值的增幅

sum：表示当前结点上升子序列长度的最大值

所以我们

向下更新的时候：

只要讲lazy 向下传递 增幅向下传递即可

向上更新的时候：

我们比价值的大小时要加上增幅(详见代码)

注意:

左边的上升子序列在比较时必须加上左边的增幅，右边的也一样

题目地址:    http://acm.uestc.edu.cn/#/problem/show/360

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAXN0 100010
#define l1(x) (x)<<1
#define r1(x) (x)>>1
#define max(a,b) ((a)>(b)?(a):(b))
struct TRnode{
    int L,R;
    int la,ra,a,lazy;
    int lsum,rsum,sum;
};
TRnode TR[MAXN0<<2];
int S[MAXN0];
void pu(int k,int k1,int k11){
    int tmp0;
    TR[k].la = TR[k1].la;
    TR[k].ra = TR[k11].ra;
    TR[k].lsum = TR[k1].lsum;
    tmp0 = TR[k1].R - TR[k1].L + 1 ;
    if(TR[k].lsum==tmp0){
        if(S[TR[k1].R]+TR[k1].ra<S[TR[k11].L]+TR[k11].la){
            TR[k].lsum += TR[k11].lsum;
        }
    }
    TR[k].rsum = TR[k11].rsum;
    tmp0 = TR[k11].R - TR[k11].L + 1;
    if(tmp0==TR[k].rsum){
        if(S[TR[k1].R]+TR[k1].ra<S[TR[k11].L]+TR[k11].la){
            TR[k].rsum += TR[k1].rsum;
        }
    }
    TR[k].sum = max(TR[k].lsum,TR[k].rsum);
    TR[k].sum = max(TR[k].sum,max(TR[k1].sum,TR[k11].sum));
    if(S[TR[k1].R]+TR[k1].ra<S[TR[k11].L]+TR[k11].la){
        //TR[k].lsum += TR[k11].lsum;
        TR[k].sum = max(TR[k].sum,TR[k1].rsum+TR[k11].lsum);
    }
}
void pd(int k,int k1,int k11){
    //TR[k].lazy = 0;
    TR[k1].la += TR[k].a;
    TR[k1].ra += TR[k].a;
    TR[k1].a +=TR[k].a;
    
    TR[k11].la += TR[k].a;
    TR[k11].ra += TR[k].a;
    TR[k11].a +=TR[k].a;
    
    TR[k1].lazy = TR[k11].lazy = TR[k].lazy;
    TR[k].a = 0;
    TR[k].lazy = 0;
}
void buildTR(int L,int R,int k){
    //int L,R;
    TR[k].L = L;
    TR[k].R = R;
    TR[k].lazy = TR[k].a = 0;
    TR[k].la = TR[k].ra = 0;
    if(L==R){
        TR[k].lsum = TR[k].rsum = TR[k].sum = 1;
        return;
    }
    int k1 = l1(k);
    int k11 = k1 + 1;
    int mid = r1(L+R);
    buildTR(L,mid,k1);
    buildTR(mid+1,R,k11);
    pu(k,k1,k11);
}
void update(int L,int R,int k,int a){
    if(TR[k].L==L&&TR[k].R==R){
        TR[k].la += a;
        TR[k].ra += a;
        TR[k].a  += a;
        TR[k].lazy = 1;
        return;
    }
    int k1,k11,mid;
    k1 = l1(k);
    k11 = k1 + 1;
    if(TR[k].lazy){
        pd(k,k1,k11);
    }
    mid = r1(TR[k].L+TR[k].R);
    if(mid>=R){
        update(L, R, k1, a);
    }
    else if(mid<L){
        update(L, R, k11, a);
    }
    else {
        update(L,mid,k1,a);
        update(mid+1,R,k11,a);
    }
    pu(k,k1,k11);
}
int query(int L,int R,int k){
    if(TR[k].L==L&&TR[k].R==R){
        return TR[k].sum;
    }
    int k1,k11;
    k1 = l1(k);
    k11 = k1+1;
    if(TR[k].lazy){
        pd(k,k1,k11);
    }
    int mid = r1(TR[k].L+TR[k].R);
    if(mid>=R){
        return query(L, R, k1);
    }
    else if(mid<L){
        return  query(L, R, k11);
    }
    else {
        int tmp0,tmp1,tmp2,tmp3;
        tmp0 = query(L, mid, k1);
        tmp1 = query(mid+1, R, k11);
        tmp3 = 0,tmp2 = 0;
        if(S[TR[k1].R]+TR[k1].ra<S[TR[k11].L]+TR[k11].la){
            tmp2 = TR[k1].rsum;
            tmp3 = mid - L + 1;
            if(TR[k1].rsum>tmp3){
                tmp2 = tmp3;
            }
            tmp3 = R - mid;
            if(TR[k11].lsum<tmp3){
                tmp3 = TR[k11].lsum;
            }
            tmp2+=tmp3;
        }
        return max(tmp0,max(tmp1,tmp2));
    }
}
int main(){
    int T,L,R;
    int N,Q,a,cas;
    
    char w[2];
    scanf("%d",&T);
    cas = 0;
    while(T--){
        scanf("%d%d",&N,&Q);
        for(int i=1;i<=N;++i){
            scanf("%d",&S[i]);
        }
        buildTR(1,N,1);
        printf("Case #%d:\n",++cas);
        while(Q--){
            scanf("%s%d%d",w,&L,&R);
            if(w[0]=='q'){
                int ans = query(L, R, 1);
                printf("%d\n",ans);
            }
            else {
                scanf("%d",&a);
                update(L,R,1,a);
            }
        }
    }
    return 0;
}