HDU3308 LCIS（线段树区间合并）

LCIS

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

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
  
  

 

Author

shǎ崽

 

Source

HDOJ Monthly Contest – 2010.02.06 

题意：求区间内最长连续上升子序列长度。

思路：保存区间包含左端点的LCIS，包含右端点的LCIS，区间内LCIS。

合并区间时，要判断左儿子是否是完全升序，若是，还要判断左儿子的右端点是否小于右儿子的左端点，如果是则要加上右儿子包含左端点的LCIS，右儿子同样。

对于整个区间的LCIS，可能来自于左右儿子的LCIS，也可能来自左右儿子的中间部分。

询问时，要求得区间要完全在左儿子或右儿子时才进行左右儿子的访问，否则的话要把被求区间的左部分和右部分的LCIS求出来，还要最中间部分处理。

#include <stdio.h>
#include <string.h>
#include <algorithm>
#define maxn 100010
#define lson rt<<1
#define rson rt<<1|1
using namespace std;
struct node{
    int left, right, mid;
    int lx, rx, mx;
    int dis(){return right-left+1;}
}tree[maxn<<2];
int a[maxn];
void pushUp(int rt){
    tree[rt].lx = tree[lson].lx+((tree[lson].lx==tree[lson].dis()&&a[tree[lson].right]<a[tree[rson].left])?tree[rson].lx:0);
     tree[rt].rx = tree[rson].rx+((tree[rson].rx==tree[rson].dis()&&a[tree[lson].right]<a[tree[rson].left])?tree[lson].rx:0);
     tree[rt].mx = max(max(tree[lson].mx, tree[rson].mx), a[tree[lson].right]<a[tree[rson].left]?(tree[lson].rx+tree[rson].lx):0);
}
void bulid(int rt, int left, int right){
    tree[rt].left = left;
    tree[rt].right = right;
    tree[rt].mid = (right+left)>>1;
    if(left==right){
        tree[rt].lx=tree[rt].rx=tree[rt].mx=1;
        return;
    }
    int mid = (right+left)>>1;
    bulid(lson, left, mid);
    bulid(rson, mid+1, right);
    pushUp(rt);
}
void update(int rt, int pos){
    if(tree[rt].left==tree[rt].right){
        tree[rt].lx=tree[rt].rx=tree[rt].mx=1;
        return;
    }
    if(pos<=tree[rt].mid) update(lson, pos);
    else update(rson, pos);
    pushUp(rt);
}
int query(int rt, int l, int r){
    if(l==tree[rt].left&&tree[rt].right==r){
        return tree[rt].mx;
    }
    if(r<=tree[rt].mid) return query(lson, l, r);
    else if(l>tree[rt].mid) return query(rson, l, r);
    else{
        int ltmp = query(lson, l, tree[rt].mid);
        int rtmp = query(rson, tree[rt].mid+1, r);
        int sum = 0;
        if(a[tree[lson].right]<a[tree[rson].left])
            sum =  min(tree[rt].mid-l+1, tree[lson].rx) + min(r-tree[rt].mid, tree[rson].lx);
        return max(max(ltmp, rtmp), sum);
    }
}
int main()
{
    int T, n, m, i, A, B;
    char q[3];
    scanf("%d", &T);
    while(T--){
        scanf("%d %d", &n, &m);
        for(i = 0;i < n;i++) scanf("%d", &a[i]);
        bulid(1, 0, n-1);
        while(m--){
            scanf("%s %d %d", q, &A, &B);
            if(q[0]=='U'){
                a[A] = B;
                update(1, A);
            }else printf("%d\n", query(1, A, B));    
        }
    }
}