• Splay 专辑


    Splay写的真是抑郁,各种被坑。。。

    被题坑,被自己坑。

    一直在调程序。。。

    Splay模板:

    View Code
      1 #include <iostream>
      2 #include <algorithm>
      3 #include <cstring>
      4 #include <cstdlib>
      5 #include <cstdio>
      6 
      7 #define N 170000
      8 #define INF 2e9
      9 
     10 using namespace std;
     11 
     12 int son[N][2],fa[N],val[N],sum[N];
     13 int n,m,ans,a,w,root,cnt;
     14 
     15 inline void prt(int x,int dp)//调试专用,用不上最好 
     16 {
     17     if(!x) return;
     18     prt(son[x][0],dp+1); printf("%d    %d\n",val[x],dp); prt(son[x][1],dp+1);
     19 }
     20 
     21 inline void pushup(int x)
     22 {
     23     sum[x]=sum[son[x][0]]+sum[son[x][1]]+1;
     24 }
     25 
     26 inline void link(int x,int y,int c)//c=0 left   c=1 right
     27 {
     28     fa[x]=y;
     29     son[y][c]=x;
     30 }
     31 
     32 void rotate(int x,int c)//c=0 left   c=1 right
     33 {
     34     int y=fa[x];
     35     link(x,fa[y],son[fa[y]][1]==y);
     36     link(son[x][!c],y,c);
     37     link(y,x,!c);
     38     pushup(y);
     39 }
     40 
     41 void splay(int x,int g)
     42 {
     43     while(fa[x]!=g)
     44     {
     45         int y=fa[x];
     46         int cy=(son[fa[y]][1]==y),cx=(son[y][1]==x);
     47         if(fa[y]==g) rotate(x,cx);
     48         else
     49         {
     50             if(cx==cy) rotate(y,cy);
     51             else rotate(x,cx);
     52             rotate(x,cy);
     53         }    
     54     }
     55     pushup(x);
     56     if(!g) root=x;
     57 }
     58 
     59 void newnode(int y,int &x,int sp)
     60 {
     61     x=++cnt;
     62     fa[x]=y; val[x]=sp; sum[x]=1;
     63     son[x][0]=son[x][1]=0;
     64 } 
     65 
     66 void init()
     67 {
     68     newnode(cnt=0,root,-INF);
     69     newnode(root,son[root][1],INF);
     70     sum[root]=2;
     71 }
     72 
     73 void insert(int sp)
     74 {
     75     int x=root;
     76     while(son[x][val[x]<sp]) x=son[x][val[x]<sp];
     77     newnode(x,son[x][val[x]<sp],sp);
     78     splay(cnt,0);
     79 }
     80 
     81 int pred(int sp)
     82 {
     83     int x=root,rt=-INF;
     84     while(x)
     85     {
     86         if(val[x]==sp) return sp;
     87         if(val[x]<sp) rt=max(rt,val[x]);
     88         x=son[x][val[x]<sp];
     89     }
     90     return rt;
     91 }
     92 
     93 int succ(int sp)
     94 {
     95     int x=root,rt=INF;
     96     while(x)
     97     {
     98         if(val[x]==sp) return sp;
     99         if(val[x]>sp) rt=min(rt,val[x]);
    100         x=son[x][val[x]<sp];
    101     }
    102     return rt;
    103 }
    104 
    105 int find(int sp)
    106 {
    107     int x=root,rt=0;
    108     while(x)
    109     {
    110         if(val[x]==sp) rt=x;
    111         x=son[x][val[x]<sp];
    112     }
    113     return rt;
    114 }
    115 
    116 int del(int sp)//return the total number of the deleted numbers  区间删除 
    117 {
    118     int x=find(sp),rt=0;
    119     if(x)
    120     {
    121         splay(1,0);
    122         splay(x,1);
    123         rt=sum[son[x][0]];
    124         son[x][0]=0;//delete (0,val[x])
    125         splay(x,0); 
    126     }
    127     return rt;
    128 }
    129 
    130 inline void DEL(int sp)//单点删除 一个sp值的点 
    131 {
    132     int x=find(sp);
    133     splay(x,0);
    134     if(son[x][0]&&son[x][1])
    135     {
    136         int y=getmax(son[x][0]);
    137         splay(y,x);
    138         fa[y]=0; root=y; fa[son[x][1]]=root; son[y][1]=son[x][1];
    139         pushup(y);
    140     }
    141     else if(son[x][0]) fa[son[x][0]]=0,root=son[x][0];
    142     else if(son[x][1]) fa[son[x][1]]=0,root=son[x][1];
    143 }
    144 
    145 int select(int k,int g)//return the value of the kth largest number
    146 {
    147     int x=root;
    148     while(sum[son[x][1]]!=k)
    149     {
    150         if(sum[son[x][1]]>k) x=son[x][1];
    151         else k=k-sum[son[x][1]]-1,x=son[x][0];
    152     }
    153     splay(x,g);
    154     return val[x];
    155 }
    156 
    157 void go()
    158 {
    159     char str[10];
    160     init();
    161     ans=w=0;
    162     while(n--)
    163     {
    164         scanf("%s%d",str,&a);
    165         if(str[0]=='I')
    166         {
    167             a-=w;
    168             if(a>=m-w) insert(a);
    169         }
    170         else if(str[0]=='A') w+=a;
    171         else if(str[0]=='S')
    172         {
    173             w-=a;
    174             ans+=del(succ(m-w));
    175         }
    176         else if(str[0]=='F')
    177         {
    178             if(sum[root]<a+2) puts("-1");
    179             else printf("%d\n",select(a,0)+w);
    180         }
    181     }
    182     printf("%d\n",ans);
    183 }
    184 
    185 int main()
    186 {
    187     while(~scanf("%d%d",&n,&m)) go();
    188     return 0;
    189 }

    BZOJ 1503:

    View Code
      1 #include <iostream>
      2 #include <cstdio>
      3 #include <cstring>
      4 #include <cstdlib>
      5 #include <algorithm>
      6 
      7 #define INF 1e9
      8 #define N 1000000
      9 
     10 using namespace std;
     11 
     12 int fa[N],son[N][2],sz[N],val[N];
     13 int n,cnt,root,ans,dt,mn;
     14 
     15 inline void pushup(int x)
     16 {
     17     sz[x]=sz[son[x][0]]+sz[son[x][1]]+1;
     18 }
     19 
     20 inline void link(int x,int y,int c)
     21 {
     22     fa[x]=y; son[y][c]=x;
     23 }
     24 
     25 inline void rotate(int x,int c)
     26 {
     27     int y=fa[x];
     28     link(x,fa[y],son[fa[y]][1]==y);
     29     link(son[x][!c],y,c);
     30     link(y,x,!c);
     31     pushup(y);
     32 }
     33 
     34 inline void splay(int x,int g)
     35 {
     36     while(fa[x]!=g)
     37     {
     38         int y=fa[x];
     39         int cy=(son[fa[y]][1]==y),cx=(son[y][1]==x);
     40         if(fa[y]==g) rotate(x,cx);
     41         else
     42         {
     43             if(cx==cy) rotate(y,cy);
     44             else rotate(x,cx);
     45             rotate(x,cy);
     46         }
     47     }
     48     pushup(x);
     49     if(!g) root=x; 
     50 }
     51 
     52 inline void newnode(int y,int &x,int sp)
     53 {
     54     x=++cnt;
     55     fa[x]=y; val[x]=sp; sz[x]=1;
     56     son[x][0]=son[x][1]=0;
     57 }
     58 
     59 inline void init()
     60 {
     61     cnt=0;
     62     newnode(0,root,-INF);
     63     newnode(root,son[root][1],INF);
     64     sz[root]=2;
     65 }
     66 
     67 inline void insert(int sp)
     68 {
     69     int x=root;
     70     while(son[x][sp>val[x]]) x=son[x][sp>val[x]];
     71     newnode(x,son[x][sp>val[x]],sp);
     72     splay(cnt,0);
     73 }
     74 
     75 inline int find(int sp)
     76 {
     77     int x=root,res=0;
     78     while(x)
     79     {
     80         if(val[x]==sp) res=x;
     81         x=son[x][sp>val[x]];
     82     }
     83     return res;
     84 }
     85 
     86 inline int del(int sp)
     87 {
     88     int x=find(sp),res=0;
     89     if(x)
     90     {
     91         splay(1,0);
     92         splay(x,1);
     93         res=sz[son[x][0]];
     94         son[x][0]=0;
     95         splay(x,0);
     96     }
     97     return res;
     98 }
     99 
    100 inline int succ(int sp)
    101 {
    102     int x=root,res=INF;
    103     while(x)
    104     {
    105         if(val[x]==sp) return sp;
    106         if(sp<val[x]) res=min(res,val[x]);
    107         x=son[x][sp>val[x]];
    108     }
    109     return res;
    110 }
    111 
    112 inline int select(int k,int g)
    113 {
    114     int x=root;
    115     while(sz[son[x][1]]!=k)
    116     {
    117         if(k<sz[son[x][1]]) x=son[x][1];
    118         else k-=sz[son[x][1]]+1,x=son[x][0];
    119     }
    120     splay(x,g);
    121     return val[x];
    122 }
    123 
    124 inline void go()
    125 {
    126     init();
    127     scanf("%d%d",&n,&mn);
    128     ans=dt=0;
    129     char str[10];int a;
    130     while(n--)
    131     {
    132         scanf("%s%d",str,&a);
    133         if(str[0]=='I')
    134         {
    135             a-=dt;
    136             if(a>=mn-dt) insert(a);
    137         }
    138         else if(str[0]=='A') dt+=a;
    139         else if(str[0]=='S')
    140         {
    141             dt-=a;
    142             ans+=del(succ(mn-dt));
    143         }
    144         else
    145         {
    146             if(sz[root]-2<a) puts("-1");
    147             else printf("%d\n",select(a,0)+dt);
    148         }
    149     }
    150     printf("%d\n",ans);
    151 }
    152 
    153 int main()
    154 {
    155     go();
    156     return 0;
    157 } 

    BZOJ 1588:

    View Code
      1 #include <iostream>
      2 #include <cstdio>
      3 #include <cstring>
      4 #include <cstdlib>
      5 #include <algorithm>
      6 
      7 #define INF 1e9
      8 #define N 1000000
      9 
     10 using namespace std;
     11 
     12 int son[N][2],fa[N],sz[N],val[N];
     13 int n,cnt,root,ans;
     14 
     15 
     16 inline void pushup(int x)
     17 {
     18     sz[x]=sz[son[x][0]]+sz[son[x][1]]+1;
     19 }
     20 
     21 inline void link(int x,int y,int c)
     22 {
     23     fa[x]=y; son[y][c]=x;
     24 }
     25 
     26 inline void rotate(int x,int c)
     27 {
     28     int y=fa[x];
     29     link(x,fa[y],son[fa[y]][1]==y);
     30     link(son[x][!c],y,c);
     31     link(y,x,!c);
     32     pushup(y);
     33 }
     34 
     35 inline void splay(int x,int g)
     36 {
     37     while(fa[x]!=g)
     38     {
     39         int y=fa[x];
     40         int cy=(son[fa[y]][1]==y),cx=(son[y][1]==x);
     41         if(fa[y]==g) rotate(x,cx);
     42         else
     43         {
     44             if(cx==cy) rotate(y,cy);
     45             else rotate(x,cx);
     46             rotate(x,cy);
     47         }
     48     }
     49     pushup(x);
     50     if(!g) root=x;
     51 }
     52 
     53 inline void newnode(int y,int &x,int sp)
     54 {
     55     x=++cnt;
     56     fa[x]=y; val[x]=sp; sz[x]=1;
     57     son[x][0]=son[x][1]=0;
     58 }
     59 
     60 inline void init()
     61 {
     62     cnt=0;
     63     newnode(0,root,-INF);
     64     newnode(root,son[root][1],INF);
     65     sz[root]=2;
     66 }
     67 
     68 inline void insert(int sp)
     69 {
     70     int x=root;
     71     while(son[x][sp>val[x]]) x=son[x][sp>val[x]];
     72     newnode(x,son[x][sp>val[x]],sp);
     73     splay(cnt,0);
     74 }
     75 
     76 inline int pred(int sp)
     77 {
     78     int x=root,res=-INF;
     79     while(x)
     80     {
     81         if(val[x]==sp) return sp;
     82         if(val[x]<sp) res=max(res,val[x]);
     83         x=son[x][sp>val[x]];
     84     }
     85     return res;
     86 }
     87 
     88 inline int succ(int sp)
     89 {
     90     int x=root,res=INF;
     91     while(x)
     92     {
     93         if(val[x]==sp) return sp;
     94         if(val[x]>sp) res=min(res,val[x]);
     95         x=son[x][sp>val[x]];
     96     }
     97     return res;
     98 }
     99 
    100 inline void go()
    101 {
    102     init();
    103     scanf("%d%d",&n,&ans);insert(ans);
    104     for(int i=2,a;i<=n;i++)
    105     {
    106         if(scanf("%d",&a)==EOF) a=0;
    107         int f1=pred(a);
    108         int f2=succ(a);
    109         ans+=min(f2-a,a-f1);
    110         insert(a);
    111     }
    112     printf("%d\n",ans);
    113 }
    114 
    115 int main()
    116 {
    117     go();
    118     return 0;
    119 } 

    HDU 1754:

    View Code
      1 #include <iostream>
      2 #include <algorithm>
      3 #include <cstring>
      4 #include <cstdio>
      5 #include <cstdlib>
      6 
      7 #define N 1000000
      8 #define INF 1e9
      9 
     10 using namespace std;
     11 
     12 int son[N][2],val[N],bh[N],fa[N],mx[N];
     13 int n,cnt,root,m;
     14 
     15 inline void prt(int x,int dp)
     16 {
     17     if(!x) return;
     18     prt(son[x][0],dp+1); printf("%d    %d\n",val[x],dp); prt(son[x][1],dp+1);
     19 }
     20 
     21 inline void pushup(int x)
     22 {
     23     mx[x]=max(val[x],max(mx[son[x][0]],mx[son[x][1]]));
     24 }
     25 
     26 inline void link(int x,int y,int c)
     27 {
     28     fa[x]=y; son[y][c]=x;
     29 }
     30 
     31 inline void rotate(int x,int c)
     32 {
     33     int y=fa[x];
     34     link(x,fa[y],son[fa[y]][1]==y);
     35     link(son[x][!c],y,c);
     36     link(y,x,!c);
     37     pushup(y);
     38 }
     39 
     40 inline void splay(int x,int g)
     41 {
     42     while(fa[x]!=g)
     43     {
     44         int y=fa[x];
     45         int cy=(son[fa[y]][1]==y),cx=(son[y][1]==x);
     46         if(fa[y]==g) rotate(x,cx);
     47         else
     48         {
     49             if(cx==cy) rotate(y,cy);
     50             else rotate(x,cx);
     51             rotate(x,cy);
     52         }
     53     }
     54     pushup(x);
     55     if(!g) root=x;
     56 }
     57 
     58 inline void newnode(int y,int &x,int sp,int b)//细节 
     59 {
     60     x=++cnt;
     61     fa[x]=y; val[x]=sp; bh[x]=b;
     62     son[x][0]=son[x][1]=0;
     63 }
     64 
     65 inline void init()
     66 {
     67     cnt=0;
     68     newnode(0,root,-INF,0);
     69     newnode(root,son[root][1],INF,n+1);
     70 }
     71 
     72 inline void insert(int sp,int b)
     73 {
     74     int x=root;
     75     while(son[x][b>bh[x]]) x=son[x][b>bh[x]];
     76     newnode(x,son[x][b>bh[x]],sp,b);
     77     splay(cnt,0);//细节 
     78 }
     79 
     80 inline int getpos(int b)
     81 {
     82     int x=root;
     83     while(x)
     84     {
     85         if(bh[x]==b) return x;
     86         x=son[x][b>bh[x]];
     87     }
     88 }
     89 
     90 inline void querymax(int l,int r)
     91 {
     92     int f1=getpos(l-1);
     93     int f2=getpos(r+1);
     94     splay(f1,0);splay(f2,f1);
     95     printf("%d\n",mx[son[f2][0]]);
     96 }
     97 
     98 inline void change(int b,int sp)
     99 {
    100     int f1=getpos(b);
    101     splay(f1,0); val[f1]=sp;
    102     pushup(f1);
    103 }
    104 
    105 inline void go()
    106 {
    107     init();mx[0]=-INF;
    108     for(int i=1,a;i<=n;i++)
    109     {
    110         scanf("%d",&a);
    111         insert(a,i);
    112     }
    113     //prt(root,0);
    114     char str[10];
    115     for(int i=1,a,b;i<=m;i++)
    116     {
    117         scanf("%s%d%d",str,&a,&b);
    118         if(str[0]=='Q')
    119         {
    120             if(a>b) swap(a,b);
    121             querymax(a,b);
    122         }
    123         else change(a,b);
    124     }
    125 }
    126 
    127 int main()
    128 {
    129     while(scanf("%d%d",&n,&m)!=EOF) go();
    130     return 0;
    131 } 

    HDU 1890:

    View Code
      1 #include <iostream>
      2 #include <cstring>
      3 #include <cstdio>
      4 #include <cstdlib>
      5 #include <algorithm>
      6 
      7 #define N 1000000
      8 #define BUG system("pause")
      9 
     10 using namespace std;
     11 
     12 struct PX
     13 {
     14     int nu,id;
     15 }px[N];
     16 
     17 int id[N],pos[N],son[N][2],fa[N],rev[N],sz[N];
     18 int cnt,root,n;
     19 
     20 inline bool cmp(const PX &a,const PX &b)
     21 {
     22     if(a.nu!=b.nu) return a.nu<b.nu;
     23     return a.id<b.id;
     24 }
     25 
     26 inline bool cmp1(const PX &a,const PX &b)
     27 {
     28     return a.id<b.id;
     29 }
     30 
     31 inline void pushup(int x)
     32 {
     33     sz[x]=sz[son[x][0]]+sz[son[x][1]]+1;
     34 }
     35 
     36 inline void reverse(int x)
     37 {
     38     if(!x) return;
     39     rev[x]^=1;
     40 }
     41 
     42 inline void pushdown(int x)
     43 {
     44     if(!x||!rev[x]) return;
     45     rev[x]=0;
     46     reverse(son[x][0]);
     47     reverse(son[x][1]);
     48     swap(son[x][0],son[x][1]);
     49 }
     50 
     51 inline void link(int x,int y,int c)
     52 {
     53     fa[x]=y; son[y][c]=x;
     54 }
     55 
     56 inline void rotate(int x,int c)
     57 {
     58     int y=fa[x];
     59     pushdown(y);
     60     pushdown(x); 
     61     link(x,fa[y],son[fa[y]][1]==y);
     62     link(son[x][!c],y,c);
     63     link(y,x,!c);
     64     pushup(y);
     65 }
     66 
     67 inline void splay(int x,int g)
     68 {
     69     pushdown(x);
     70     while(fa[x]!=g)
     71     {
     72         int y=fa[x];
     73         pushdown(fa[y]); pushdown(y); pushdown(x);
     74         int cy=(son[fa[y]][1]==y),cx=(son[y][1]==x);
     75         if(fa[y]==g) rotate(x,cx);
     76         else
     77         {
     78             if(cx==cy) rotate(y,cy);
     79             else rotate(x,cx);
     80             rotate(x,cy);
     81         }
     82     }
     83     pushup(x);
     84     if(!g) root=x;
     85 }
     86 
     87 inline void newnode(int y,int &x)
     88 {
     89     x=++cnt;
     90     fa[x]=y; sz[x]=1; rev[x]=0;
     91     son[x][0]=son[x][1]=0;
     92 }
     93 
     94 inline void init()
     95 {
     96     cnt=0;
     97     newnode(0,root);
     98     newnode(root,son[root][1]);
     99     sz[root]=2;
    100 }
    101 
    102 inline int getmax(int x)//在任何有pushdown的操作中,从上向下时必须提前pushdown! 
    103 {
    104     pushdown(x);
    105     while(son[x][1])
    106     {
    107         x=son[x][1];
    108         pushdown(x);
    109     }
    110     return x;
    111 }
    112 
    113 inline void del()
    114 {
    115     int x=root;
    116     if(son[x][0]&&son[x][1])
    117     {
    118         int y=getmax(son[x][0]);
    119         splay(y,x);
    120         fa[y]=0; root=y; fa[son[x][1]]=root; son[y][1]=son[x][1];
    121         pushup(y);
    122     }
    123     else if(son[x][0]) fa[son[x][0]]=0,root=son[x][0];
    124     else if(son[x][1]) fa[son[x][1]]=0,root=son[x][1];
    125 }
    126 
    127 inline void build(int &x,int l,int r,int g)
    128 {
    129     if(l>r) return;
    130     int mid=(l+r)>>1;
    131     newnode(g,x);
    132     pos[id[mid]]=x;
    133     build(son[x][0],l,mid-1,x);
    134     build(son[x][1],mid+1,r,x);
    135     pushup(x);
    136 }
    137 
    138 inline void go()
    139 {
    140     init();
    141     for(int i=1;i<=n;i++)
    142     {
    143         scanf("%d",&px[i].nu);
    144         px[i].id=i;
    145     }
    146     sort(px+1,px+1+n,cmp);
    147     for(int i=1;i<=n;i++) id[px[i].id]=i;
    148     sort(px+1,px+1+n,cmp1);
    149     build(son[son[root][1]][0],1,n,son[root][1]);
    150     pushup(son[root][1]);
    151     pushup(root);
    152     for(int i=1;i<=n;i++)
    153     {
    154         splay(pos[i],0); splay(1,pos[i]);
    155         printf("%d",i+sz[son[1][1]]);
    156         if(i<n) printf(" ");
    157         rev[son[1][1]]^=1;
    158         del();
    159     }
    160     puts("");
    161 }
    162 
    163 int main()
    164 {
    165     while(scanf("%d",&n),n) go();
    166     return 0;
    167 }

    BZOJ 1208:

    View Code
      1 #include <iostream>
      2 #include <cstring>
      3 #include <cstdio>
      4 #include <cstdlib>
      5 #include <algorithm>
      6 
      7 #define mod 1000000
      8 #define N 1000000
      9 #define INF 1e9
     10 
     11 using namespace std;
     12 
     13 int son[N][2],sz[N],val[N],fa[N];
     14 int n,root,cnt,people,ans;
     15 
     16 
     17 inline void prt(int x,int dp)
     18 {
     19     if(!x) return;
     20     prt(son[x][0],dp+1); printf("%d    %d\n",val[x],dp); prt(son[x][1],dp+1);
     21 }
     22 
     23 inline void pushup(int x)
     24 {
     25     sz[x]=sz[son[x][0]]+sz[son[x][1]]+1;
     26 }
     27 
     28 inline void link(int x,int y,int c)
     29 {
     30     fa[x]=y; son[y][c]=x;
     31 }
     32 
     33 inline void rotate(int x,int c)
     34 {
     35     int y=fa[x];
     36     link(x,fa[y],son[fa[y]][1]==y);
     37     link(son[x][!c],y,c);
     38     link(y,x,!c);
     39     pushup(y);
     40 }
     41 
     42 inline void splay(int x,int g)
     43 {
     44     while(fa[x]!=g)
     45     {
     46         int y=fa[x];
     47         int cy=(son[fa[y]][1]==y),cx=(son[y][1]==x);
     48         if(fa[y]==g) rotate(x,cx);
     49         else 
     50         {
     51             if(cx==cy) rotate(y,cy);
     52             else rotate(x,cx);
     53             rotate(x,cy);
     54         }
     55     }
     56     pushup(x);
     57     if(!g) root=x;
     58 }
     59 
     60 inline void newnode(int y,int &x,int sp)
     61 {
     62     x=++cnt;
     63     fa[x]=y; val[x]=sp; sz[x]=1;
     64     son[x][0]=son[x][1]=0;
     65 }
     66 
     67 inline void init()
     68 {
     69     cnt=0;
     70     newnode(0,root,-INF);
     71     newnode(root,son[root][1],INF);
     72     sz[root]=2;
     73 }
     74 
     75 inline void insert(int sp)
     76 {
     77     int x=root;
     78     while(son[x][sp>val[x]]) x=son[x][sp>val[x]];
     79     newnode(x,son[x][sp>val[x]],sp);
     80     splay(cnt,0);
     81 }
     82 
     83 inline int pred(int sp)
     84 {
     85     int x=root,res=-INF;
     86     while(x)
     87     {
     88         if(sp==val[x]) res=val[x];
     89         else if(sp>val[x]) res=max(res,val[x]);
     90         x=son[x][sp>val[x]];
     91     }
     92     return res;
     93 }
     94 
     95 inline int succ(int sp)
     96 {
     97     int x=root,res=INF;
     98     while(x)
     99     {
    100         if(sp==val[x]) res=val[x];
    101         else if(sp<val[x]) res=min(res,val[x]);
    102         x=son[x][sp>val[x]];
    103     }
    104     return res;
    105 }
    106 
    107 inline int getmax(int x)
    108 {
    109     while(son[x][1]) x=son[x][1];
    110     return x;
    111 }
    112 
    113 inline int find(int sp)
    114 {
    115     int x=root,res=0;
    116     while(x)
    117     {
    118         if(val[x]==sp) res=x;
    119         x=son[x][sp>val[x]];
    120     }
    121     return res;
    122 }
    123 
    124 inline void del(int sp)//单点删除 
    125 {
    126     int x=find(sp);
    127     splay(x,0);
    128     if(son[x][0]&&son[x][1])
    129     {
    130         int y=getmax(son[x][0]);
    131         splay(y,x);
    132         fa[y]=0; root=y; fa[son[x][1]]=root; son[y][1]=son[x][1];
    133         pushup(y);
    134     }
    135     else if(son[x][0]) fa[son[x][0]]=0,root=son[x][0];
    136     else if(son[x][1]) fa[son[x][1]]=0,root=son[x][1];
    137 }
    138 
    139 inline void go()
    140 {
    141     init();
    142     scanf("%d",&n);
    143     int pd,da;
    144     while(n--)
    145     {
    146         scanf("%d%d",&pd,&da);
    147         if(sz[root]==2||pd==people)
    148         {
    149             people=pd;
    150             insert(da);
    151             continue;
    152         }
    153         int f1=pred(da);
    154         int f2=succ(da);
    155         if(da-f1<=f2-da) ans+=(da-f1)%mod,del(f1);
    156         else ans+=(f2-da)%mod,del(f2);
    157         ans%=mod;
    158     }
    159     printf("%d\n",ans);
    160 }
    161 
    162 int main()
    163 {
    164     go();
    165     return 0;
    166 }

    BZOJ 1269:

    View Code
      1 #include <iostream>
      2 #include <cstring>
      3 #include <cstdlib>
      4 #include <cstdio>
      5 #include <algorithm>
      6 
      7 #define N 5000000
      8 
      9 using namespace std;
     10 
     11 int sz[N],son[N][2],fa[N];
     12 char val[N];
     13 bool rev[N];
     14 int m,root,cnt,gb;
     15 char str[N];
     16 
     17 inline void pushup(int x)
     18 {
     19     sz[x]=sz[son[x][0]]+sz[son[x][1]]+1;
     20 }
     21 
     22 inline void reverse(int x)
     23 {
     24     if(!x) return;
     25     rev[x]^=1;
     26 }
     27 
     28 inline void pushdown(int x)
     29 {
     30     if(!x||!rev[x]) return;
     31     rev[x]=0;
     32     reverse(son[x][0]);
     33     reverse(son[x][1]);
     34     swap(son[x][0],son[x][1]);
     35 }
     36 
     37 inline void link(int x,int y,int c)
     38 {
     39     fa[x]=y; son[y][c]=x;
     40 }
     41 
     42 inline void rotate(int x,int c)
     43 {
     44     int y=fa[x];
     45     pushdown(y);
     46     pushdown(x);
     47     link(x,fa[y],son[fa[y]][1]==y);
     48     link(son[x][!c],y,c);
     49     link(y,x,!c);
     50     pushup(y);
     51 }
     52 
     53 inline void splay(int x,int g)
     54 {
     55     while(fa[x]!=g)
     56     {
     57         int y=fa[x];
     58         pushdown(fa[y]); pushdown(y); pushdown(x);
     59         int cy=(son[fa[y]][1]==y),cx=(son[y][1]==x);
     60         if(fa[y]==g) rotate(x,cx);
     61         else
     62         {
     63             if(cx==cy) rotate(y,cy);
     64             else rotate(x,cx);
     65             rotate(x,cy);
     66         }
     67     }
     68     pushup(x);
     69     if(!g) root=x;
     70 }
     71 
     72 inline void newnode(int y,int &x,char b)
     73 {
     74     x=++cnt;
     75     fa[x]=y; sz[x]=1; val[x]=b;
     76     son[x][0]=son[x][1]=0;
     77 }
     78 
     79 inline void init()
     80 {
     81     cnt=0;
     82     newnode(0,root,'~');
     83     newnode(root,son[root][1],'!');
     84     sz[root]=2;
     85 }
     86 
     87 inline void build(int &x,int l,int r,int g)
     88 {
     89     if(l>r) return;
     90     int mid=(l+r)>>1;
     91     newnode(g,x,str[mid]);
     92     build(son[x][0],l,mid-1,x);
     93     build(son[x][1],mid+1,r,x);
     94     pushup(x);
     95 }
     96 
     97 inline int find(int b)
     98 {
     99     int x=root;
    100     pushdown(x);
    101     while(x)
    102     {
    103         if(sz[son[x][0]]+1==b) return x;
    104         if(sz[son[x][0]]+1>b) x=son[x][0];
    105         else b-=sz[son[x][0]]+1,x=son[x][1];
    106         pushdown(x);
    107     }
    108     while(1);return -1e9;
    109 }
    110 
    111 inline void INSERT(int sl)
    112 {
    113     int x=find(gb),y=find(gb-1);
    114     splay(y,0); splay(x,y);
    115     build(son[x][0],1,sl,x);
    116     pushup(x); pushup(y);
    117 }
    118 
    119 inline void DELETE(int k)
    120 {
    121     int x=find(gb+k),y=find(gb-1);
    122     splay(y,0); splay(x,y);
    123     fa[son[x][0]]=0; son[x][0]=0;
    124     pushup(x); pushup(y);
    125 }
    126 
    127 inline void REVERSE(int k)
    128 {
    129     int x=find(gb+k),y=find(gb-1);
    130     splay(y,0); splay(x,y);
    131     rev[son[x][0]]^=1;
    132 }
    133 
    134 inline void go()
    135 {
    136     init(); gb=2;
    137     scanf("%d",&m);
    138     for(int i=1,a;i<=m;i++)
    139     {
    140         scanf("%s",str);
    141         if(str[0]=='M')
    142         {
    143             scanf("%d",&a);
    144             gb=a+2;
    145         }
    146         else if(str[0]=='I')
    147         {
    148             scanf("%d",&a);getchar();
    149             gets(str+1);
    150             INSERT(a);
    151         }
    152         else if(str[0]=='D')
    153         {
    154             scanf("%d",&a);
    155             DELETE(a);
    156         }
    157         else if(str[0]=='R')
    158         {
    159             scanf("%d",&a);
    160             REVERSE(a);
    161         }
    162         else if(str[0]=='G')
    163         {
    164             printf("%c\n",val[find(gb)]);
    165         }
    166         else if(str[0]=='P')
    167         {
    168             gb--;
    169         }
    170         else if(str[0]=='N')
    171         {
    172             gb++;
    173         }
    174     }
    175 }
    176 
    177 int main()
    178 {
    179     go();
    180     return 0;
    181 } 

    POJ 3468:

    View Code
      1 #include <iostream>
      2 #include <cstdio>
      3 #include <cstdlib>
      4 #include <algorithm>
      5 #include <cstring>
      6 
      7 #define N 200000
      8 #define INF 1LL<<50
      9 
     10 using namespace std;
     11 //带区间更新的splay模板 
     12 __int64 sum[N],val[N],dt[N];
     13 int bh[N],son[N][2],fa[N],sz[N];
     14 int n,m,root,cnt;
     15 
     16 inline void pushup(__int64 x)
     17 {
     18     sum[x]=sum[son[x][0]]+sum[son[x][1]]+val[x];
     19     sz[x]=sz[son[x][0]]+sz[son[x][1]]+1;
     20 }
     21 
     22 inline void renew(int x,__int64 d)
     23 {
     24     if(!x) return;
     25     sum[x]+=sz[x]*d;
     26     val[x]+=d;
     27     dt[x]+=d;
     28 }
     29 
     30 inline void pushdown(int x)
     31 {
     32     if(!x||dt[x]==0) return;
     33     renew(son[x][0],dt[x]); renew(son[x][1],dt[x]);
     34     dt[x]=0;
     35 }
     36 
     37 inline void link(int x,int y,int c)
     38 {
     39     fa[x]=y; son[y][c]=x;
     40 }
     41 
     42 inline void rotate(int x,int c)
     43 {
     44     int y=fa[x];
     45     pushdown(y);
     46     pushdown(x);
     47     link(x,fa[y],son[fa[y]][1]==y);
     48     link(son[x][!c],y,c);
     49     link(y,x,!c);
     50     pushup(y);
     51 }
     52 
     53 inline void splay(int x,int g)
     54 {
     55     while(fa[x]!=g)
     56     {
     57         int y=fa[x];
     58         int cy=(son[fa[y]][1]==y),cx=(son[y][1]==x);
     59         if(fa[y]==g) rotate(x,cx);
     60         else
     61         {
     62             if(cx==cy) rotate(y,cy);
     63             else rotate(x,cx);
     64             rotate(x,cy);
     65         }
     66     }
     67     pushup(x);
     68     if(!g) root=x;
     69 }
     70 
     71 inline void newnode(int y,int &x,__int64 sp,int b)
     72 {
     73     x=++cnt;
     74     fa[x]=y; val[x]=sp; bh[x]=b; sum[x]=val[x]; dt[x]=0; sz[x]=1;
     75     son[x][0]=son[x][1]=0;
     76 }
     77 
     78 inline void init()
     79 {
     80     cnt=0;
     81     newnode(0,root,-INF,0);
     82     newnode(root,son[root][1],INF,n+1);
     83     sz[root]=2;
     84 }
     85 
     86 inline void insert(__int64 sp,int b)
     87 {
     88     int x=root;
     89     while(son[x][b>bh[x]]) x=son[x][b>bh[x]];
     90     newnode(x,son[x][b>bh[x]],sp,b);
     91     splay(cnt,0);
     92 }
     93 
     94 inline int getpos(int b)
     95 {
     96     int x=root;
     97     while(x)
     98     {
     99         if(bh[x]==b) return x;
    100         x=son[x][b>bh[x]];
    101     }
    102 }
    103 
    104 inline void increase(int l,int r,__int64 sp)
    105 {
    106     int f1=getpos(l-1);
    107     int f2=getpos(r+1);
    108     splay(f1,0); splay(f2,f1);
    109     renew(son[f2][0],sp);
    110 }
    111 
    112 inline void getsum(int l,int r)
    113 {
    114     int f1=getpos(l-1);
    115     int f2=getpos(r+1);
    116     splay(f1,0); splay(f2,f1);
    117     printf("%I64d\n",sum[son[f2][0]]);
    118 }
    119 
    120 inline void go()
    121 {
    122     init();
    123     for(int i=1,a;i<=n;i++)
    124     {
    125         scanf("%I64d",&a);
    126         insert(a,i);
    127     }
    128     char str[10];__int64 c;
    129     for(int i=1,a,b,c;i<=m;i++)
    130     {
    131         scanf("%s",str);
    132         if(str[0]=='C')
    133         {
    134             scanf("%d%d%I64d",&a,&b,&c);
    135             increase(a,b,c);
    136         }
    137         else
    138         {
    139             scanf("%d%d",&a,&b);
    140             getsum(a,b);
    141         }
    142     }
    143 }
    144 
    145 int main()
    146 {
    147     while(scanf("%d%d",&n,&m)!=EOF) go();
    148     return 0;
    149 }

    BZOJ 1500:集Splay的大多数功能于一身~

    View Code
      1 #include <iostream>
      2 #include <cstring>
      3 #include <cstdlib>
      4 #include <cstdio>
      5 #include <algorithm>
      6 
      7 #define N 500000
      8 #define INF 1e8
      9 #define BUG system("pause")
     10 
     11 using namespace std;
     12 
     13 int sz[N],sum[N],val[N],mx[N],lmx[N],rmx[N],fa[N],son[N][2];
     14 bool rev[N],lz[N];
     15 int q[N],h,ss[N];
     16 int n,m,posi,tot,num,root,cnt;
     17 
     18 inline void prt()
     19 {
     20     for(int i=1;i<=cnt;i++)    printf("%d    %d     %d     %d      %d     %d\n",i,son[i][0],son[i][1],sz[i],val[i],rev[i]);
     21 }
     22 
     23 inline void pushup(int x)
     24 {
     25     sz[x]=sz[son[x][0]]+sz[son[x][1]]+1;
     26     sum[x]=sum[son[x][0]]+sum[son[x][1]]+val[x];
     27     lmx[x]=max(lmx[son[x][0]],max(sum[son[x][0]]+val[x],sum[son[x][0]]+val[x]+lmx[son[x][1]]));
     28     rmx[x]=max(rmx[son[x][1]],max(sum[son[x][1]]+val[x],sum[son[x][1]]+val[x]+rmx[son[x][0]]));
     29     mx[x]=max(max(mx[son[x][0]],mx[son[x][1]]),val[x]+max(0,lmx[son[x][1]])+max(0,rmx[son[x][0]]));
     30 }
     31 
     32 inline void reverse(int x)
     33 {
     34     if(!x) return;
     35     rev[x]^=1;
     36     swap(son[x][0],son[x][1]);
     37     swap(lmx[x],rmx[x]);
     38 }
     39 
     40 inline void renew(int x,int sp)
     41 {
     42     if(!x) return;
     43     val[x]=sp; lz[x]=true;
     44     sum[x]=sz[x]*sp;
     45     lmx[x]=rmx[x]=mx[x]=max(sp,sum[x]);
     46 }
     47 
     48 inline void pushdown(int x)
     49 {
     50     if(!x) return;
     51     if(rev[x])
     52     {
     53         rev[x]=false;
     54         reverse(son[x][0]);
     55         reverse(son[x][1]);
     56     }
     57     if(lz[x])
     58     {
     59         lz[x]=false;
     60         renew(son[x][0],val[x]);
     61         renew(son[x][1],val[x]);
     62     }
     63 } 
     64 
     65 inline void link(int x,int y,int c)
     66 {
     67     fa[x]=y; son[y][c]=x;
     68 }
     69 
     70 inline void rotate(int x,int c)
     71 {
     72     int y=fa[x];
     73     link(x,fa[y],son[fa[y]][1]==y);
     74     link(son[x][!c],y,c);
     75     link(y,x,!c);
     76     pushup(y);
     77 }
     78 
     79 inline void splay(int x,int g)
     80 {
     81     while(fa[x]!=g)
     82     {
     83         int y=fa[x];
     84         pushdown(fa[y]); pushdown(y); pushdown(x);
     85         int cy=(son[fa[y]][1]==y),cx=(son[y][1]==x);
     86         if(fa[y]==g) rotate(x,cx);
     87         else 
     88         {
     89             if(cx==cy) rotate(y,cy);
     90             else rotate(x,cx);
     91             rotate(x,cy);
     92         }
     93     }
     94     pushup(x);
     95     if(!g) root=x;
     96 }
     97 
     98 inline int getnum()
     99 {
    100     if(h==0) return ++cnt;
    101     return q[h--];
    102 }
    103 
    104 inline void newnode(int y,int &x,int sp)
    105 {
    106     x=getnum();
    107     fa[x]=y; sz[x]=1; val[x]=sum[x]=mx[x]=lmx[x]=rmx[x]=sp; rev[x]=lz[x]=0;
    108     son[x][0]=son[x][1]=0;
    109 }
    110 
    111 inline void init()
    112 {
    113     cnt=0;
    114     newnode(0,root,-INF);
    115     newnode(root,son[root][1],INF);
    116     sz[root]=2;
    117 }
    118 
    119 inline void build(int &x,int l,int r,int g)
    120 {
    121     if(l>r) return;
    122     int mid=(l+r)>>1;
    123     newnode(g,x,ss[mid]);
    124     build(son[x][0],l,mid-1,x);
    125     build(son[x][1],mid+1,r,x);
    126     pushup(x);
    127 }
    128 
    129 inline int find(int b)
    130 {
    131     int x=root;
    132     pushdown(x);
    133     while(x)
    134     {
    135         if(sz[son[x][0]]==b) return x;
    136         else if(sz[son[x][0]]>b) x=son[x][0];
    137         else b-=sz[son[x][0]]+1,x=son[x][1];
    138         pushdown(x);
    139     }
    140 }
    141 
    142 inline void recycle(int x)
    143 {
    144     if(!x) return;
    145     q[++h]=x;
    146     recycle(son[x][0]);
    147     recycle(son[x][1]);
    148 }
    149 
    150 inline void INSERT()
    151 {
    152     int x=find(posi),y=find(posi+1);
    153     splay(x,0); splay(y,x);
    154     build(son[y][0],1,tot,y);
    155     pushup(y); pushup(x);
    156 }
    157 
    158 inline void DELETE()
    159 {
    160     int x=find(posi-1),y=find(posi+tot);
    161     splay(x,0); splay(y,x);
    162     recycle(son[y][0]); 
    163     fa[son[y][0]]=0;
    164     son[y][0]=0;
    165     pushup(y); pushup(x);
    166 }
    167 
    168 inline void SAME()
    169 {
    170     int x=find(posi-1),y=find(posi+tot);
    171     splay(x,0); splay(y,x);
    172     renew(son[y][0],num);
    173     pushup(y); pushup(x);
    174 }
    175 
    176 inline void REVERSE()
    177 {
    178     int x=find(posi-1),y=find(posi+tot);
    179     splay(x,0); splay(y,x);
    180     reverse(son[y][0]);
    181     pushup(y); pushup(x);
    182 }
    183 
    184 inline void MAXSUM()
    185 {
    186     splay(1,0); splay(2,1);
    187     printf("%d\n",mx[son[2][0]]);
    188 }
    189 
    190 inline void GETSUM()
    191 {
    192     int x=find(posi-1),y=find(posi+tot);
    193     splay(x,0); splay(y,x);
    194     printf("%d\n",sum[son[y][0]]);
    195 }
    196 
    197 inline void go()
    198 {
    199     init();
    200     mx[0]=lmx[0]=rmx[0]=val[0]=-INF;
    201     scanf("%d%d",&n,&m);
    202     for(int i=1;i<=n;i++) scanf("%d",&ss[i]);
    203     build(son[son[root][1]][0],1,n,son[root][1]);
    204     pushup(son[root][1]);
    205     pushup(root);
    206     char str[20];
    207     while(m--)
    208     {
    209         scanf("%s",str);
    210         if(str[0]=='I')
    211         {
    212             scanf("%d%d",&posi,&tot);
    213             for(int i=1;i<=tot;i++) scanf("%d",&ss[i]);
    214             INSERT();
    215         }
    216         else if(str[0]=='D')
    217         {
    218             scanf("%d%d",&posi,&tot);
    219             DELETE();
    220         }
    221         else if(str[0]=='M')
    222         {
    223             if(str[6]=='A')
    224             {
    225                 scanf("%d%d%d",&posi,&tot,&num);
    226                 SAME();
    227             }
    228             else
    229             {
    230                 MAXSUM();
    231             }
    232         }
    233         else if(str[0]=='R')
    234         {
    235             scanf("%d%d",&posi,&tot);
    236             REVERSE();
    237         }
    238         else
    239         {
    240             scanf("%d%d",&posi,&tot);
    241             GETSUM();
    242         } 
    243     }
    244 }
    245 
    246 int main()
    247 {
    248     go();
    249     return 0;
    250 } 

    复习专用。

    数据结构裸题,没有什么思维含量,主要是模拟不要写错!!!!

  • 相关阅读:
    struts2后台返回json到jsp页面
    潜搜索——搜索界的趋势
    pat1022__字符串查找
    PAT1055___排序神题
    Codeforces Round #205 (Div. 2)C 选取数列可以选择的数使总数最大——dp
    Codeforces Round #204 (Div. 2) C. Jeff and Rounding——数学规律
    队列模拟题——pat1026. Table Tennis
    骰子点数概率__dp
    PAT1034. Head of a Gang ——离散化+并查集
    回文字符串的变形——poj1159
  • 原文地址:https://www.cnblogs.com/proverbs/p/2860717.html
Copyright © 2020-2023  润新知