uestc Another LCIS

Another LCIS

Time Limit: 1000 ms Memory Limit: 65536 kB Solved: 193 Tried: 2428

Description

For a sequence S1,S2,...,SN, and a pair of integers (i, j), if 1 <= i <= j <= N and Si < Si+1 < Si+2 <...< Sj-1 < Sj, then the sequence Si,Si+1,...,Sj is a CIS (Continuous Increasing Subsequence). The longest CIS of a sequence is called the LCIS (Longest Continuous Increasing Subsequence).In this problem, we will give you a sequence first, and then some “add” operations and some “query” operations. An add operation adds a value to each member in a specified interval. For a query operation, you should output the length of the LCIS of a specified interval.

Input

The first line of the input is an integer T, which stands for the number of test cases you need to solve.Every test case begins with two integers N, Q, where N is the size of the sequence, and Q is the number of queries. S1,S2,...,SN are specified on the next line, and then Q queries follow. Every query begins with a character ‘a’ or ‘q’. ‘a’ is followed by three integers L, R, V, meaning that add V to members in the interval [L, R] (including L, R), and ‘q’ is followed by two integers L, R, meaning that you should output the length of the LCIS of interval [L, R].

T <= 10;

1 <= N, Q <= 100000;

1 <= L <= R <= N;

-10000 <= S1,S2,...,SN, V <= 10000.

Output

For every test case, you should output "Case #k:" on a single line first, where k indicates the case number and starts at 1. Then for every ‘q’ query, output the answer on a single line. See sample for more details.

Sample Input

1

5 6

0 1 2 3 4

q 1 4

a 1 2 -10

a 1 1 -6

a 5 5 -4

q 2 3

q 4 4

Sample Output

Case #1:421

Source

The 9th UESTC Programming Contest Preliminary

 #include<stdio.h>
 #define HH 1
 struct st
 {
     int l,r;
     int lnum,rnum;
     int max;
     int lmax,rmax;
     int color;
     int num;
 } f[*];
 int date[];
 int max(int x,int y)
 {
     if(x>y)
         return x;
     else return y;
 }
 int min(int x,int y)
 {
     if(x<y)
         return x;
     else return y;
 }
 int Max(int x,int y,int z,int t,int b)
 {
     return max(max(max(x,y),z),max(t,b));
 }
 void up(struct st *fa,struct st *lll,struct st *rrr)
 {
     fa->lnum=lll->lnum;
     fa->rnum=rrr->rnum;
     if(lll->rnum>=rrr->lnum)
     {
         fa->lmax=lll->lmax;
         fa->rmax=rrr->rmax;
         fa->max=max(lll->max,rrr->max);
     }
     else if(lll->rnum<rrr->lnum)
     {
         fa->lmax=(lll->lmax==(lll->r-lll->l+))? lll->lmax+rrr->lmax:lll->lmax;
         fa->rmax=(rrr->rmax==(rrr->r-rrr->l+))? rrr->rmax+lll->rmax:rrr->rmax;
         fa->max=Max(fa->lmax,fa->rmax,lll->max,rrr->max,lll->rmax+rrr->lmax);
     }
 }
 void down(int n)
 {
     if(f[n*].color==HH)
         f[n*].num+=f[n].num;
     else f[n*].num=f[n].num;
     f[n*].lnum+=f[n].num;
     f[n*].rnum+=f[n].num;

     if(f[n*+].color==HH)
         f[n*+].num+=f[n].num;
     else f[n*+].num=f[n].num;
     f[n*+].lnum+=f[n].num;
     f[n*+].rnum+=f[n].num;

     f[n*].color=HH;

     f[n*+].color=HH;

     f[n].color=;
     f[n].num=;
 }
 void build(int l,int r,int n)
 {
     int mid=(l+r)/;
     f[n].l=l;
     f[n].r=r;
     f[n].color=;
     f[n].num=;
     if(l==r)
     {
         f[n].lmax=;
         f[n].rmax=;
         f[n].max=;
         f[n].lnum=date[l];
         f[n].rnum=date[l];
         return ;
     }
     build(l,mid,n*);
     build(mid+,r,n*+);
     up(&f[n],&f[n*],&f[n*+]);
 }
 void update(int l,int r,int num,int n)
 {
     int mid=(f[n].l+f[n].r)/;
     if(f[n].l==l&&f[n].r==r)
     {
         if(f[n].color==HH)
             f[n].num=f[n].num+num;
         else f[n].num=num;
         f[n].color=HH;
         f[n].lnum+=num;
         f[n].rnum+=num;
         return ;
     }
     if(f[n].color==HH)
         down(n);
     if(mid>=r)
         update(l,r,num,n*);
     else if(mid<l)
         update(l,r,num,n*+);
     else
     {
         update(l,mid,num,n*);
         update(mid+,r,num,n*+);
     }
     up(&f[n],&f[n*],&f[n*+]);
 }
 int query(int l,int r,int n)
 {
     int mid=(f[n].l+f[n].r)/;
     int a=,b=,ans=;
     if(f[n].l==l&&f[n].r==r)
     {
         return f[n].max;
     }
     if(f[n].color==HH)
         down(n);
     if(mid>=r)
         return query(l,r,n*);
     else if(mid<l)
         return query(l,r,n*+);
     a=query(l,mid,n*);
     b=query(mid+,r,n*+);
     if(f[n*].rnum>=f[n*+].lnum)
         ans=max(a,b);
     else if(f[n*].rnum<f[n*+].lnum)
     {
         ans=max(max(a,b),min(mid-l+,f[n*].rmax)+min(r-mid,f[n*+].lmax));
     }
     return ans;
 }
 int main()
 {
     int i,j,k,n,m,l,r,num,t;
     char c[];
     while(scanf("%d",&t)>)
     {
         for(i=; i<=t; i++)
         {
             scanf("%d%d",&n,&m);
             for(j=; j<=n; j++)
                 scanf("%d",&date[j]);
             build(,n,);
             printf("Case #%d:\n",i);
             getchar();
             for(j=; j<=m; j++)
             {
                 scanf("%s",c);
                 if(c[]=='q')
                 {
                     scanf("%d%d",&l,&r);
                     k=query(l,r,);
                     printf("%d\n",k);
                 }
                 else if(c[]=='a')
                 {
                     scanf("%d%d%d",&l,&r,&num);
                     update(l,r,num,);
                 }
             }
         }
     }
     return ;
 }