（线段树）hdoj 3308-LCIS

Given n integers. 
You have two operations: 
U A B: replace the Ath number by B. (index counting from 0) 
Q A B: output the length of the longest consecutive increasing subsequence (LCIS) in a,ba,b. 

InputT in the first line, indicating the case number. 
Each case starts with two integers n , m(0<n,m<=10 ⁵). 
The next line has n integers(0<=val<=10 ⁵). 
The next m lines each has an operation: 
U A B(0<=A,n , 0<=B=10 ⁵) 
OR 
Q A B(0<=A<=B< n). 
OutputFor each Q, output the answer.Sample Input

1
10 10
7 7 3 3 5 9 9 8 1 8 
Q 6 6
U 3 4
Q 0 1
Q 0 5
Q 4 7
Q 3 5
Q 0 2
Q 4 6
U 6 10
Q 0 9

Sample Output

1
1
4
2
3
1
2
5

#include <iostream>
//#include<bits/stdc++.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <math.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int MAX=1e5+5;
struct node
{
    int left,right,mid;
    int x,y;
}st[10*MAX];
void pushup(int l,int r,int k)
{
    st[k].left=st[2*k].left;
    st[k].right=st[2*k+1].right;
    st[k].mid=max(st[2*k].mid,st[2*k+1].mid);
    st[k].x=st[2*k].x;
    st[k].y=st[2*k+1].y;
    if(st[2*k].y<st[2*k+1].x)
    {
        st[k].mid=max(st[k].mid,st[2*k].right+st[2*k+1].left);
        if(st[2*k].left==(l+r)/2-l)
            st[k].left=st[2*k].left+st[2*k+1].left;
        if(st[2*k+1].right==r-(l+r)/2)
            st[k].right=st[2*k+1].right+st[2*k].right;
    }
}
void init(int l,int r,int k)
{
    st[k].left=st[k].right=st[k].mid=r-l;
    if(l+1==r)
    {
        scanf("%d",&st[k].x);
        st[k].y=st[k].x;
        return;
    }
    init(l,(l+r)/2,2*k);
    init((l+r)/2,r,2*k+1);
    pushup(l,r,k);
}
void update(int l,int r,int ul,int ur,int val,int k)//当下[l,r), 目标更新[ul,ur) 为val
{
    if(ul==l&&ur==r)
    {
        st[k].x=st[k].y=val;
        return;
    }
    int mid=(l+r)/2;
    if(mid>=ur)
        update(l,mid,ul,ur,val,2*k);
    if(mid<=ul)
        update(mid,r,ul,ur,val,2*k+1);
    st[k].mid=max(st[2*k].mid,st[2*k+1].mid);
    st[k].left=st[2*k].left;
    st[k].right=st[2*k+1].right;
    st[k].x=st[2*k].x;
    st[k].y=st[2*k+1].y;
    if(st[2*k].y<st[2*k+1].x)
    {
        st[k].mid=max(st[k].mid,st[2*k].right+st[2*k+1].left);
    if(st[2*k].left==(l+r)/2-l)
        st[k].left+=st[2*k+1].left;
    if(st[2*k+1].right==r-(l+r)/2)
        st[k].right+=st[2*k].right;
    }
    return;
}
int query(int l,int r,int ql,int qr,int k)
{
    if(l>=ql&&r<=qr)
        return st[k].mid;
    int mid=(l+r)/2;
    if(mid<=ql)
        return query(mid,r,ql,qr,2*k+1);
    else if(mid>=qr)
        return query(l,mid,ql,qr,2*k);
    else
    {
        int an;
        an=max(query(l,mid,ql,qr,2*k),query(mid,r,ql,qr,2*k+1));
        if(st[2*k].y<st[2*k+1].x)
            an=max(an,min(st[2*k].right,mid-ql)+min(st[2*k+1].left,qr-mid));
        return an;
    }
}
int t;
int N,M;
char op[10];
int qq,pp;
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d %d",&N,&M);
        init(1,N+1,1);
        for(int i=1;i<=M;i++)
        {
            scanf("%s %d %d",op,&qq,&pp);
            qq++;
            if(op[0]=='U')
            {
                update(1,N+1,qq,qq+1,pp,1);
            }
            else
            {
                pp++;
                printf("%d
",query(1,N+1,qq,pp+1,1));
            }
        }
    }
}