hdu--3308 LCIS（线段树+区间合并）

Description

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, b]. 

Input

T 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). 

Output

For 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
题意：给出一列n个数，进行m次操作，把第a的值变为b，查询[a,b]之间的最长连续上升子序列的长度，对于每个查询输出结果
思路：用线段树进行存当前节点的最大长度以及左边开始的长度和右边结束的长度，然后向上更新。查询时和线段树的查询一样，就是在查询时要注意对左右边界的更新。
AC代码：

#include<iostream>  
#include<fstream>  
#include<iomanip>  
#include<cstdio>  
#include<cstring>  
#include<algorithm>  
#include<cstdlib>  
#include<cmath>  
#include<set>  
#include<map>  
#include<queue>  
#include<stack>  
#include<string>  
#include<vector>  
#include<ctime>  
#include<sstream>  
#include<cassert> 
using namespace std;
const int maxn=100005;
struct note
{
    int l,r,lm,rm,m;
} a[maxn<<2];
int p[maxn];
int build(int l,int r,int k)
{
    a[k].l=l;
    a[k].r=r;
    a[k].lm=a[k].rm=a[k].m=0;
    if(l==r)
    {
        return 0;
    }
    int mid=(l+r)/2;
    build(l,mid,k*2);
    build(mid+1,r,k*2+1);
    return 0;
}
int pushup(int k)
{
    if(p[a[k*2].r]>=p[a[k*2+1].l])
    {
        a[k].m=max(a[k*2].m,a[k*2+1].m);
        a[k].lm=a[k*2].lm;
        a[k].rm=a[k*2+1].rm;
    }
    else
    {
        a[k].m=max(max(a[k*2].rm+a[k*2+1].lm,a[k*2].m),a[k*2+1].m);
        if(a[k*2].lm==(a[k*2].r-a[k*2].l+1))
            a[k].lm=a[k*2].lm+a[k*2+1].lm;
        else
            a[k].lm=a[k*2].lm;
        if(a[k*2+1].rm==(a[k*2+1].r-a[k*2+1].l+1))
            a[k].rm=a[k*2].rm+a[k*2+1].rm;
        else
            a[k].rm=a[k*2+1].rm;
    }
    return 0;
}
int ins(int n,int d,int k)
{
    if(a[k].l==a[k].r&&a[k].l==d)
    {
        a[k].rm=a[k].lm=a[k].m=1;
        return 0;
    }
    if(a[k*2].r>=d) ins(n,d,k*2);
    else if(a[k*2+1].l<=d) ins(n,d,k*2+1);
    pushup(k);
    return 0;
}
int sea(int l,int r,int k)
{
    if(l==a[k].l&&a[k].r==r)
    {
        return a[k].m;
    }
    if(a[k*2].r>=r) return sea(l,r,k*2);
    else if(a[k*2+1].l<=l) return sea(l,r,k*2+1);
    else
    {
        int t1=sea(l,a[k*2].r,k*2);
        int t2=sea(a[k*2+1].l,r,k*2+1);
        int ans=max(t1,t2);
        int sum=0;
        if(p[a[k*2].r]<p[a[k*2+1].l])
        sum=min(a[k*2].r-l+1,a[k*2].rm)+min(r-a[k*2].r,a[k*2+1].lm);
        return max(ans,sum);
    }
}
int main()
{
    int n,m,t,c,b;
    scanf("%d",&t);
    {
        for(int kk=1; kk<=t; kk++)
        {
            scanf("%d%d",&n,&m);
            build(1,n,1);
            for(int i=1; i<=n; i++)
            {
                scanf("%d",&c);
                p[i]=c;
                ins(c,i,1);
            }
            char s[10];
            for(int i=0; i<m; i++)
            {
                scanf("%s",s);
                if(s[0]=='U')
                {
                    scanf("%d%d",&c,&b);
                    p[c+1]=b;
                    ins(b,c+1,1);
                }
                else
                {
                    scanf("%d%d",&c,&b);
                    printf("%d
",sea(c+1,b+1,1));
                }
            }
        }
    }
    return 0;
}