hdu 3308 LCIS

LCIS

Time Limit: 6000/2000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 2640    Accepted Submission(s): 1143

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

/**
这是一道经典的线段树题目。
有分治的思想在里面
求解区间[L , R]最长递增子序列的长度。

对于一个线段树的区间
我们需要保存左端点的值，右端点的值，
以及分别包含左右端点所能达到的最长递增子序列的长度
lmaxn ，rmaxn；还要有一个保存区间最彻底子序列的值maxn。

**/
#include<iostream>
#include<stdio.h>
#include<cstring>
#include<cstdlib>
using namespace std;

struct node
{
    int l,r,len;
    int lnum,rnum,lmaxn,rmaxn,maxn;
}f[100002*4];
int date;

/**
向上更新函数。
**/
void up(int n,int LChild,int RChild)
{
    f[n].lnum = f[LChild].lnum;
    f[n].rnum = f[RChild].rnum;

    f[n].lmaxn = (f[LChild].lmaxn==f[LChild].len && f[LChild].rnum<f[RChild].lnum)?
                          f[LChild].lmaxn+f[RChild].lmaxn:f[LChild].lmaxn;
    f[n].rmaxn = (f[RChild].rmaxn==f[RChild].len && f[LChild].rnum<f[RChild].lnum)?
                          f[RChild].rmaxn+f[LChild].rmaxn:f[RChild].rmaxn;

    f[n].maxn = max(f[LChild].maxn,f[RChild].maxn);
    if(f[LChild].rnum<f[RChild].lnum)
        f[n].maxn = max(f[n].maxn,f[LChild].rmaxn+f[RChild].lmaxn);
  //  f[n].maxn = max(f[n].maxn,max(f[n].lmaxn,f[n].rmaxn));
/**
这里可以不用这句  f[n].maxn = max(f[n].maxn,max(f[n].lmaxn,f[n].rmaxn));
思考吧。
**/
}
void build(int l,int r,int n)
{
    int mid=(l+r)/2;
    f[n].l = l;
    f[n].r = r;
    f[n].len = f[n].r-f[n].l+1;
    f[n].lnum=f[n].rnum=0;
    f[n].lmaxn=f[n].rmaxn=f[n].maxn=0;
    if(l==r)
    {
        scanf("%d",&date);
        f[n].lnum=f[n].rnum=date;
        f[n].lmaxn=f[n].rmaxn=f[n].maxn=1;
        return;
    }
    build(l,mid,n*2);
    build(mid+1,r,n*2+1);
    up(n,n*2,n*2+1);
}
void update(int wz,int num,int n)
{
    int mid=(f[n].l + f[n].r)/2;
    if(f[n].l == wz && f[n].r == wz)
    {
        f[n].lnum=f[n].rnum=num;
        f[n].lmaxn=f[n].rmaxn=f[n].maxn=1;
        return;
    }
    if(mid>=wz) update(wz,num,n*2);
    else if(mid<wz) update(wz,num,n*2+1);
    up(n,n*2,n*2+1);
}

int query(int l,int r,int n)
{
    int mid=(f[n].l + f[n].r)/2;
    if(f[n].l == l && f[n].r == r)
    {
        return f[n].maxn;
    }
    if(mid>=r) return query(l,r,n*2);
    else if(mid<l) return query(l,r,n*2+1);
    else {
            /**
            这里也需要注意。
            **/
            int lmaxn = query(l,mid,n*2); //查询左边最大值
            int rmaxn =query(mid+1,r,n*2+1);//查询右边最大值
            int maxn = 0;
            if(f[n*2].rnum<f[n*2+1].lnum) //这个也需要讨论。
                maxn = min(mid-l+1,f[n*2].rmaxn)+min(r-mid,f[n*2+1].lmaxn);
            maxn = max(maxn,max(lmaxn,rmaxn));
            return maxn;
    }
}
int main()
{
    int T,n,m;
    int l,r,wz,num;
    char a[10];
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        build(1,n,1);
        while(m--)
        {
            scanf("%s",a);
            if(a[0] == 'Q')
            {
                scanf("%d%d",&l,&r);
                l++,r++;
                printf("%d\n",query(l,r,1));
            }
            else if(a[0]=='U')
            {
                scanf("%d%d",&wz,&num);
                wz++;
                update(wz,num,1);
            }
        }
    }
    return 0;
}