hdu3308LCIS(线段树，点更新，段查寻，查寻时一定要注意跨越时如何计算)

Problem 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

题意：输入Q，则查寻范围[A,B]内的最长升序，输入U，则更新点A的值变成B。

解题：记录第个节点的最左端的升序长度，最右端的升序的长度和在这个范围内的最长升序。而父节点的则是由左右节点产生。

1. 左儿子最右边的值 < 右儿子最左边的值

    lMax = (左儿子的lMax == 左儿子的len) ? 左儿子的len + 右儿子的lMax : 左儿子的lMax;
    rMax = (右儿子的rMax == 右儿子的len) ? 右儿子的len + 左儿子的rMax : 右儿子的rMax;
    Max  = MAX(左儿子的rMax + 右儿子的lMax, 左儿子的Max, 右儿子的Max, lMax, rMax);

2. 左儿子最右边的值 >= 右儿子最左边的值
    lMax = 左儿子的lMax;
    rMax = 右儿子的rMax;
    Max  = MAX(左儿子的Max, 右儿子的Max);

注意：在查寻时，当跨越左右子树时则一这要注意这个，当 左节点的最右边的值< 右节点的最左边的值时，那么有可能最长升序在这时最大，并且不能超过这个范围。

#include<stdio.h>
#define N 500010
struct node
{
    int Llcis,Rlcis,lcis;//最左连续升序长度，最右连续升序长度，这个范围的最长连续升序长度
}tree[8*N];
int num[N+5];
int max(int a,int b){ return a>b?a:b;}
void chang_tree(int l,int r,int k)//根据第K个节点的左右节点,计算第K个节点的最左，最右和最长 的升序长度
{
    int m=(l+r)/2;
     node ltree=tree[k*2],rtree=tree[k*2+1];
    if(num[m]>=num[m+1])//当左节点的最右边的值不小右节点的最左边的值时
    {
        tree[k].Llcis=ltree.Llcis;
        tree[k].Rlcis=rtree.Rlcis;
        tree[k].lcis=max(ltree.lcis,rtree.lcis);
    }
    else
    {
        if(m-l+1==ltree.Llcis) tree[k].Llcis=ltree.Llcis+rtree.Llcis;
           else  tree[k].Llcis=ltree.Llcis;
        if(r-m==rtree.Rlcis) tree[k].Rlcis=rtree.Rlcis+ltree.Rlcis;
            else  tree[k].Rlcis=rtree.Rlcis;
        tree[k].lcis=max(ltree.lcis,ltree.Rlcis+rtree.Llcis);
        tree[k].lcis=max(tree[k].lcis,rtree.lcis);
        tree[k].lcis=max(tree[k].lcis,tree[k].Llcis);
        tree[k].lcis=max(tree[k].lcis,tree[k].Rlcis);
    }
}
void build(int l,int r,int k)
{
    int m=(l+r)/2;
    if(l==r){
        tree[k].Llcis=1;
        tree[k].lcis=1;
        tree[k].Rlcis=1;
        return ;
    }
    build(l,m,k*2);
    build(m+1,r,k*2+1);
    chang_tree(l,r,k);
}
void updata(int l,int r,int k,int Q,int ans)
{
    int m=(l+r)/2;
    if(l==Q&&Q==r)
    {num[Q]=ans; return ;}
    if(Q<=m) updata(l,m,k*2,Q,ans);
    if(Q>m) updata(m+1,r,k*2+1,Q,ans);
    chang_tree(l,r,k);
}
int maxlen;
void find(int l,int r,int k,int L,int R)
{
    int m=(l+r)/2;
    if(L<=l&&r<=R){
           maxlen=max(tree[k].lcis,maxlen);
           return ;
    }
    if(R<=m) find(l,m,k*2,L,R);
    else if(L>m) find(m+1,r,k*2+1,L,R);
    else{
        find(l,m,k*2,L,R);
        find(m+1,r,k*2+1,L,R);
    //-----当查寻夸越左右子树时,左子树的最右端点的值小于右子树的最左端点的值------
        if(num[m]<num[m+1])
            if(L<=m-tree[2*k].Rlcis+1&&m+tree[k*2+1].Llcis<=R)//注意这个条件
           maxlen=max(tree[k*2].Rlcis+tree[k*2+1].Llcis,maxlen);
            else if(L<=m-tree[2*k].Rlcis+1&&m+tree[k*2+1].Llcis>R)//注意这个条件
              maxlen=max(tree[k*2].Rlcis+R-m,maxlen);
            else if(L>m-tree[2*k].Rlcis+1&&m+tree[k*2+1].Llcis<=R)//注意这个条件
                maxlen=max(m-L+1+tree[k*2+1].Llcis,maxlen);
            else maxlen=R-L+1;//最长的升序长度
    }
}
int main()
{
    int t,n,m,QL,QR;
    char c[2];
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)
        scanf("%d",&num[i]);
        build(1,n,1);
        while(m--)
        {
            scanf("%s%d%d",c,&QL,&QR);
            if(c[0]=='U') updata(1,n,1,QL+1,QR);
            if(c[0]=='Q')
            {
                maxlen=0; find(1,n,1,QL+1,QR+1);
                printf("%d\n",maxlen);
            }
        }
    }
}