hdu 3308 LCIS

题意：给定一个数组，可以对数组进行两种操作，一、修改某一个数组元素的值，二、查找某一段[a,b]（a，b为数组元素下标，a<=b）元素里的最长连续上升子串的长度，输出之。数组长度n，操作量m，数量级10^5

题解：因为时间只有2S，朴素算法是O（1）的修改，O（n）的查找，而对于10^5的数量级来说，2s是不够的。

因此必须要将O（n）的操作复杂度去掉，至少得O（logn）,这样我们就至少能得到一个O（m*logn）的时间复杂度的算法，对这个数量级，在2s内是可行的。

而因为是一个数组，而要O（logn）的操作复杂度那么就可以想到线段树。

线段树完全可以达到O（logn）的操作复杂度。

首先建结构体：7个变量就可以了，两个记录该节点的左右值，两个记录该节点代表的线段的最左边和最右边的元素，两个记录从最左边开始最长连续上升子串的长度和以最右为终点的最长连续上升子串的长度值，还有一个记录该段的最大连续上升子串的长度。

然后建树，建树注意各个变量的更新，

再是单点更新，对某一点进行更新相当于建树，操作类似建树。

最后就是查找区间求值，三种情况要分清：a,b<=mid;a,b>mid;mid in (a,b)之间

对于记录的当前区间的最长连续上升子串的长度这个变量是一定需要的，假如不用，则在查找时可能会出现要查找的是a=0,b=n-1，那么我们不能利用其它6个变量求出最长的连续上升子串的长度，因为可能在中间这个中间不是a和b的中间，是除它之外的中间可能出现最大值，而这个最大值我们是利用其它6个变量所得不到的，因此这个值是必要的。（之前就是因为这个变量没有，错掉了，可气的是测试用例对了，坑的死哦）

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int MAX_ = 400010;

struct point {
    int l,r,ll,rl;
    int rnum,lnum;
    int num;
}seg[MAX_];

int a,b;

void create(int k,int l,int r){
    if(l == r){
        scanf("%d",&seg[k].lnum);
        seg[k].l = seg[k].r = r;
        seg[k].ll = seg[k].rl = 1;
        seg[k].rnum = seg[k].lnum;
        seg[k].num = 1;
        return ;
    }
    int mid = (l+r)/2;
    create(2*k,l,mid);
    create(2*k+1,mid+1,r);
    seg[k].l = l;
    seg[k].r = r;
    seg[k].rnum = seg[2*k+1].rnum;
    seg[k].lnum = seg[2*k].lnum;
    seg[k].ll = seg[2*k].ll;
    seg[k].rl = seg[2*k+1].rl;
    if(seg[k].ll == seg[2*k].r - seg[2*k].l + 1){
        if(seg[2*k].rnum < seg[2*k+1].lnum){
            seg[k].ll += seg[2*k+1].ll;
        }
    }
    if(seg[k].rl == seg[2*k+1].r - seg[2*k+1].l + 1){
        if(seg[2*k].rnum < seg[2*k+1].lnum){
            seg[k].rl += seg[2*k].rl;
        }
    }
    if(seg[2*k].rnum < seg[2*k+1].lnum)
        seg[k].num = max(max(seg[k<<1].num,seg[k*2+1].num),
                                    seg[2*k].rl+seg[2*k+1].ll);
    else    seg[k].num = max(seg[k<<1].num,seg[k*2+1].num);
}

void update(int k,int l,int r){
    if(l == r){
        seg[k].lnum = seg[k].rnum = b;
        return ;
    }
    int mid = (l+r)/2;
    if(a > mid){
        update(2*k+1,mid+1,r);
    }
    else {
        update(2*k,l,mid);
    }
    seg[k].rnum = seg[2*k+1].rnum;
    seg[k].lnum = seg[2*k].lnum;
    seg[k].ll = seg[2*k].ll;
    seg[k].rl = seg[2*k+1].rl;
    if(seg[k].ll == seg[2*k].r - seg[2*k].l + 1){
        if(seg[2*k].rnum < seg[2*k+1].lnum){
            seg[k].ll += seg[2*k+1].ll;
        }
    }
    if(seg[k].rl == seg[2*k+1].r - seg[2*k+1].l + 1){
        if(seg[2*k].rnum < seg[2*k+1].lnum){
            seg[k].rl += seg[2*k].rl;
        }
    }
    if(seg[2*k].rnum < seg[2*k+1].lnum)
        seg[k].num = max(max(seg[k<<1].num,seg[k*2+1].num),
                                    seg[2*k].rl+seg[2*k+1].ll);
    else    seg[k].num = max(seg[k<<1].num,seg[k*2+1].num);
}

int find(int k,int l,int r){
    if(seg[k].l == l && seg[k].r == r){
        return seg[k].num;
        //就是这里，这里体现了num这个变量的重要性
        if(l == r) return 1;
        int tmp = max(seg[k].ll,seg[k].rl);
        if(seg[k*2].rnum < seg[k*2+1].lnum){
            tmp = max(tmp,seg[k*2].rl + seg[k*2+1].ll);
        }
        return tmp;
    }
    int mid = (seg[k].l + seg[k].r)>>1;
    if(mid >= r){
        return find(2*k,l,r);
    }
    else if(mid < l){
        return find(2*k+1,l,r);
    }
    else {
        int tmp = max(find(2*k,l,mid),find(2*k+1,mid+1,r));
        if(seg[k*2].rnum < seg[k*2+1].lnum){
            int tl = mid - l + 1;
            int tr = r - mid;
            if(seg[k*2].rl < tl){
                tl = seg[k*2].rl;
            }
            if(seg[k*2+1].ll < tr){
                tr = seg[k*2+1].ll;
            }
            tmp = max(tmp,tl+tr);
        }
        return tmp;
    }
}

int main(){
    //freopen("f:\\in.txt","r",stdin);
    int n, m, Case;
    char str[10];
    scanf("%d",&Case);
    while(Case--){
        scanf("%d%d",&n,&m);
        create(1,0,n-1);

        for(int i = 0; i < m; i++){
            scanf("%s%d%d",str,&a,&b);
            if(str[0] == 'Q'){
                printf("%d\n",find(1,a,b));
            }
            else {
                update(1,0,n-1);
            }
        }
    }
    return 0;
}