SPOJ GSS6 Can you answer these queries VI

Can you answer these queries VI

Time Limit: 2000ms

Memory Limit: 262144KB

This problem will be judged on SPOJ. Original ID: GSS6
64-bit integer IO format: %lld      Java class name: Main

Given a sequence A of N (N <= 100000) integers, you have to apply Q (Q <= 100000) operations:

Insert, delete, replace an element, find the maximum contiguous(non empty) sum in a given interval.

Input

The first line of the input contains an integer N.
The following line contains N integers, representing the starting
sequence A1..AN, (|Ai| <= 10000).

The third line contains an integer Q. The next Q lines contains the operations in following form:

I x y: insert element y at position x (between x - 1 and x).
D x  : delete the element at position x.
R x y: replace element at position x with y.
Q x y: print max{Ai + Ai+1 + .. + Aj | x <= i <= j <= y}.

All given positions are valid, and given values are between -10000 and +10000.

The sequence will never be empty.

Output

For each "Q" operation, print an integer(one per line) as described above.

Example

Input:
5
3 -4 3 -1 6
10
I 6 2
Q 3 5
R 5 -4
Q 3 5
D 2
Q 1 5
I 2 -10
Q 1 6
R 2 -1
Q 1 6

Output:
8
3
6
3
5

 

Source

my own

 

解题：splay

 #include <bits/stdc++.h>
 #define KT ch[ch[root][1]][0]
 using namespace std;
 const int INF = numeric_limits<int>::max();
 const int maxn = ;

 struct SplayTree {
     int fa[maxn],ch[maxn][],sz[maxn],key[maxn];
     int lsum[maxn],rsum[maxn],ans[maxn],sum[maxn];
     int tot,root,seq[maxn];
     inline void pushup(int x) {
         if(!x) return;
         sz[x] =  + sz[ch[x][]] + sz[ch[x][]];
         sum[x] = key[x] + sum[ch[x][]] + sum[ch[x][]];
         lsum[x] = max(lsum[ch[x][]],key[x] + sum[ch[x][]] + max(,lsum[ch[x][]]));
         rsum[x] = max(rsum[ch[x][]],key[x] + sum[ch[x][]] + max(,rsum[ch[x][]]));
         ans[x] = max(max(ans[ch[x][]],ans[ch[x][]]),key[x] + max(,rsum[ch[x][]]) + max(,lsum[ch[x][]]));
     }
     void newnode(int &x,int val,int f) {
         x = ++tot;
         lsum[x] = rsum[x] = ans[x] = sum[x] = key[x] = val;
         fa[x] = f;
         ch[x][] = ch[x][] = ;
         sz[x] = ;
     }
     void build(int &x,int L,int R,int f) {
         if(L > R) return;
         int mid = (L + R)>>;
         newnode(x,seq[mid],f);
         build(ch[x][],L,mid-,x);
         build(ch[x][],mid+,R,x);
         pushup(x);
     }
     void init(int n) {
         tot = root = ;
         ch[][] = ch[][] = fa[] = sum[] = ;
         lsum[] = rsum[] = ans[] = key[] = -INF;
         newnode(root,-INF,);
         newnode(ch[root][],-INF,root);
         build(KT,,n,ch[root][]);
         pushup(ch[root][]);
         pushup(root);
     }
     void rotate(int x,int kd) {
         int y = fa[x];
         ch[y][kd^] = ch[x][kd];
         fa[ch[x][kd]] = y;
         fa[x] = fa[y];
         ch[x][kd] = y;
         fa[y] = x;
         if(fa[x]) ch[fa[x]][y == ch[fa[x]][]] = x;
         pushup(y);
     }
     void splay(int x,int goal = ) {
         while(fa[x] != goal) {
             if(fa[fa[x]] == goal) rotate(x,x == ch[fa[x]][]);
             else {
                 int y = fa[x],z = fa[y],s = (y == ch[z][]);
                 if(x == ch[y][s]) {
                     rotate(x,s^);
                     rotate(x,s);
                 } else {
                     rotate(y,s);
                     rotate(x,s);
                 }
             }
         }
         pushup(x);
         if(!goal) root = x;
     }
     int select(int k,int goal) {
         int x = root;
         while(sz[ch[x][]] +  != k) {
             if(k < sz[ch[x][]] + ) x = ch[x][];
             else {
                 k -= sz[ch[x][]] + ;
                 x = ch[x][];
             }
         }
         splay(x,goal);
         return x;
     }
     void insert(int a,int b) {
         select(a -  + ,);
         select(a + ,root);
         newnode(KT,b,ch[root][]);
         pushup(ch[root][]);
         pushup(root);
     }
     void remove(int a) {
         select(a -  + ,);
         select(a +  + ,root);
         KT = ;
         pushup(ch[root][]);
         pushup(root);
     }
     void replace(int a,int b){
         int x = root;
         ++a;
         while(sz[ch[x][]] +  != a){
             if(a < sz[ch[x][]] + ) x = ch[x][];
             else{
                 a -= sz[ch[x][]] + ;
                 x = ch[x][];
             }
         }
         key[x] = b;
         splay(x,);
     }
     int query(int a,int b){
         select(a-+,);
         select(b++,root);
         return ans[KT];
     }
 } spt;
 int main() {
     int n,m,x,y;
     char op[];
     while(~scanf("%d",&n)) {
         for(int i = ; i <= n; ++i)
             scanf("%d",&spt.seq[i]);
         spt.init(n);
         scanf("%d",&m);
         while(m--) {
             scanf("%s",op);
             if(op[] == 'I') {
                 scanf("%d%d",&x,&y);
                 spt.insert(x,y);
             } else if(op[] == 'D') {
                 scanf("%d",&x);
                 spt.remove(x);
             }else if(op[] == 'R'){
                 scanf("%d%d",&x,&y);
                 spt.replace(x,y);
             }else if(op[] == 'Q'){
                 scanf("%d%d",&x,&y);
                 printf("%d\n",spt.query(x,y));
             }
         }
     }
     return ;
 }