bzoj1251: 序列终结者

1251: 序列终结者

Time Limit: 20 Sec  Memory Limit: 162 MB
Submit: 5285  Solved: 2294

Description

网上有许多题，就是给定一个序列，要你支持几种操作：A、B、C、D。一看另一道题，又是一个序列 要支持几种操作：D、C、B、A。尤其是我们这里的某人，出模拟试题，居然还出了一道这样的，真是没技术含量……这样 我也出一道题，我出这一道的目的是为了让大家以后做这种题目有一个“库”可以依靠，没有什么其他的意思。这道题目 就叫序列终结者吧。 【问题描述】 给定一个长度为N的序列，每个序列的元素是一个整数（废话）。要支持以下三种操作： 1. 将[L,R]这个区间内的所有数加上V。 2. 将[L,R]这个区间翻转，比如1 2 3 4变成4 3 2 1。 3. 求[L,R]这个区间中的最大值。 最开始所有元素都是0。

Input

第一行两个整数N，M。M为操作个数。 以下M行，每行最多四个整数，依次为K，L，R，V。K表示是第几种操作，如果不是第1种操作则K后面只有两个数。

Output

对于每个第3种操作，给出正确的回答。

Sample Input

4 4
1 1 3 2
1 2 4 -1
2 1 3
3 2 4

Sample Output

2
【数据范围】
N<=50000，M<=100000。
 

 

自己找了半天板子，然后终于改出来了

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e5+7,inf = 0x7fffffff;
int Fa[maxn],son[maxn][2],val[maxn],Size[maxn];
int rev[maxn],lazy[maxn],Max[maxn];
int root;
void update(int x,int v){val[x] += v,Max[x] += v,lazy[x] += v;}
void push_up(int x){
    Size[x] = 1,Max[x] = val[x];
    if(son[x][0])Max[x] = max(Max[x],Max[son[x][0]]),Size[x] += Size[son[x][0]];
    if(son[x][1])Max[x] = max(Max[x],Max[son[x][1]]),Size[x] += Size[son[x][1]];
}
void push_down(int x){
    if(lazy[x]){
        if(son[x][0])update(son[x][0],lazy[x]);
        if(son[x][1])update(son[x][1],lazy[x]);
        lazy[x] = 0;
    }
    if(rev[x]){
        rev[x] = 0;
        if(son[x][0])rev[son[x][0]] ^= 1;
        if(son[x][1])rev[son[x][1]] ^= 1;
        swap(son[x][0],son[x][1]);
    }
}
void Rotate(int x,int &k){
    int y = Fa[x],z = Fa[y],kind = son[y][0] == x;
    (y == k)?(k = x):(son[z][son[z][1] == y] = x);
    son[y][kind^1] = son[x][kind],Fa[son[y][kind^1]] = y;
    son[x][kind] = y,Fa[y] = x,Fa[x] = z;
    push_up(y);
}
void splay(int x,int &k){
    if(x == k)return;
    while(x != k){
        int y = Fa[x],z = Fa[y];
        int rx = son[y][0] == x,ry = son[z][0] == y;
        push_down(z),push_down(y),push_down(x);
        if(y != k)
            (rx == ry)?Rotate(y,k):Rotate(x,k);
        Rotate(x,k);
    }
    push_up(x);
}
void build(int l,int r,int F){
    if(l<=r){
        int mid = (l+r)/2;
        son[F][mid>F] = mid,Fa[mid] = F,Size[mid] = 1;
        //rev[mid] = val[mid] = lazy[mid] = Max[mid] = 0;
        if(l==r)return;
        build(l,mid-1,mid),build(mid+1,r,mid);
        push_up(mid);
    }
}
int Find(int k){//k -th
    int x = root,cnt;
    push_down(x);
    cnt = Size[son[x][0]];
    while(cnt+1 != k){
        x = son[x][k>cnt];
        if(k>cnt) k -= cnt+1;
        push_down(x);
        cnt = Size[son[x][0]];
    }
    return x;
}
int stk(int l,int r){
    int x = Find(l),y = Find(r+2);
    splay(x,root),splay(y,son[x][1]);
    return son[y][0];
}
int n,m,L,R,flag;
int main(){
    scanf("%d%d",&n,&m);
    root=(n+3)/2;
    build(1,n+2,root);
    while(m--){
        scanf("%d%d%d",&flag,&L,&R);
        if(flag == 1)
            scanf("%d",&flag),update(stk(L,R),flag);
        else if(flag == 2)
            rev[stk(L,R)] ^= 1;
        else
            printf("%d\n",Max[stk(L,R)]);
    }
    return 0;
}

 

 

 

splay

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e5+7,inf = 0x7fffffff;
struct Splay_tree{
    struct node{
        int val,Max,add,Size,son[2];
        bool rev;
        void init(int _val){
            val = Max = _val,Size = 1;
            add = rev = son[0] = son[1] = 0;
        }
        void update(int _val){
            Max += _val;
            val += _val;
            add += _val;
        }
    }tree[maxn];
    int Fa[maxn],root;
    void push_up(int x){
        tree[x].Max = tree[x].val,tree[x].Size = 1;
        if(tree[x].son[0]){
            tree[x].Max = max(tree[x].Max,tree[tree[x].son[0]].Max);
            tree[x].Size += tree[tree[x].son[0]].Size;
        }
        if(tree[x].son[1]){
            tree[x].Max = max(tree[x].Max,tree[tree[x].son[1]].Max);
            tree[x].Size += tree[tree[x].son[1]].Size;
        }
    }
    void push_down(int x){
        if(x == 0)return;
        int l = tree[x].son[0],r = tree[x].son[1];
        if(tree[x].add){
            if(l)tree[l].update(tree[x].add);
            if(r)tree[r].update(tree[x].add);
            tree[x].add = 0;
        }
        if(tree[x].rev){
            if(l)tree[l].rev ^= 1;
            if(r)tree[r].rev ^= 1;
            swap(tree[x].son[0],tree[x].son[1]);
            tree[x].rev = 0;
        }
    }
    void Rotate(int x,int kind){
        int y = Fa[x],z = Fa[y];
        tree[y].son[!kind] = tree[x].son[kind],Fa[tree[x].son[kind]] = y;
        tree[x].son[kind] = y,Fa[y] = x;
        tree[z].son[tree[z].son[1]==y] = x,Fa[x] = z;
        push_up(y);
    }
    void Splay(int x,int goal){
        if(x == goal)return;
        while(Fa[x]!=goal){
            int y = Fa[x],z = Fa[y];
            push_down(z),push_down(y),push_down(x);
            int rx = tree[y].son[0] == x,ry = tree[z].son[0] == y;
            if(z == goal)Rotate(x,rx);
            else{
                if(rx == ry)Rotate(y,ry);
                else Rotate(x,rx);
                Rotate(x,ry);
            }
        }
        push_up(x);
        if(goal == 0)root = x;
    }
    int Select(int pos){
        int u = root;
        push_down(u);
        while(tree[tree[u].son[0]].Size!=pos){
            if(pos<tree[tree[u].son[0]].Size)u = tree[u].son[0];
            else{
                pos -= tree[tree[u].son[0]].Size+1;
                u = tree[u].son[1];
            }
            push_down(u);
        }
        return u;
    }
    int stk(int L,int R){
        int u = Select(L-1), v = Select(R+1);
        Splay(u,0);
        Splay(v,u);
        return tree[v].son[0];
    }
    void update(int L,int R,int val){
        int pos = stk(L,R);
        tree[pos].update(val);
    }
    void Reverse(int L,int R){
        int pos = stk(L,R);
        tree[pos].rev ^= 1;
    }
    int query(int L,int R){
        int pos = stk(L,R);
        return tree[pos].Max;
    }
    int build(int L,int R){
        if(L>R)return 0;
        if(L==R)return L;
        int mid = (L+R)>>1,sL,sR;
        tree[mid].son[0] = sL = build(L,mid-1);
        tree[mid].son[1] = sR = build(mid+1,R);
        Fa[sL] = Fa[sR] = mid;
        push_up(mid);
        return mid;
    }
    void init(int n){
        tree[0].init(-inf),tree[1].init(-inf),tree[n+2].init(-inf);
        for(int i=2;i<=n+1;i++)tree[i].init(0);
        root = build(1,n+2),Fa[root] = 0;
        Fa[0] = 0,tree[0].son[1] = root,tree[0].Size = 0;
    }
}splay;
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    splay.init(n);
    for(int i=0,a,b,c,d;i<m;i++){
        scanf("%d",&a);
        if(a == 1){
            scanf("%d%d%d",&b,&c,&d);
            splay.update(b,c,d);
        }else if(a == 2){
            scanf("%d%d",&b,&c);
            splay.Reverse(b,c);
        }else{
            scanf("%d%d",&b,&c);
            printf("%d\n",splay.query(b,c));
        }
    }
    return 0;
}

 

 

Fhq Treap

/*
    author:revolIA
    submit:;
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e5+5;
int l[maxn],r[maxn],val[maxn],Size[maxn];
int rom[maxn],cnt;
int flag[maxn],lazy[maxn],Max[maxn];
int root,opt,n,m,a,x,y,z;
void update(int x,int w){
    val[x] += w;
    lazy[x] += w;
    Max[x] += w;
}
void push_up(int x){
    Size[x] = 1+Size[l[x]]+Size[r[x]];
    Max[x] = val[x];
    if(l[x])Max[x] = max(Max[x],Max[l[x]]);
    if(r[x])Max[x] = max(Max[x],Max[r[x]]);
}
void push_down(int x){
    if(flag[x]){
        swap(l[x],r[x]);
        flag[l[x]] ^= 1;
        flag[r[x]] ^= 1;
        flag[x] = 0;
    }
    if(lazy[x]){
        if(l[x])update(l[x],lazy[x]);
        if(r[x])update(r[x],lazy[x]);
        lazy[x] = 0;
    }
}
int New(int x){
    Size[++cnt] = 1;
    val[cnt] = Max[cnt] = x;
    rom[cnt] = rand() << 15 | rand();
    lazy[cnt] = flag[cnt] = 0;
    return cnt;
}
void split(int u,int k,int &x,int &y){
    if(!u){x = y = 0;return;}
    push_down(u);
    if(Size[l[u]]<k)x = u,split(r[u],k-Size[l[u]]-1,r[u],y);
    else y = u,split(l[u],k,x,l[u]);
    push_up(u);
}
int Merge(int x,int y){
    if(x*y == 0)return x+y;
    if(rom[x]<rom[y]){
        push_down(x);
        r[x] = Merge(r[x],y);
        return push_up(x),x;
    }
    push_down(y);
    l[y] = Merge(x,l[y]);
    return push_up(y),y;
}
int main(){
    srand(time(0));
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)root = Merge(root,New(0));
    while(m--){
        int K,L,R,V;
        scanf("%d%d%d",&K,&L,&R);
        split(root,L-1,x,y);
        split(y,R-L+1,y,z);
        if(K == 1){
            scanf("%d",&V);
            update(y,V);
        }else if(K == 2){
            flag[y] ^= 1;
        }else{
            printf("%d\n",Max[y]);
        }
        root = Merge(Merge(x,y),z);
    }
    return 0;
}