Serega and Fun Codeforces - 455D || queue

https://codeforces.com/problemset/problem/455/D

其实方法很多，然而当初一个也想不到...

1.分块，块内用链表维护

修改[l,r]就当成删除第r个元素，在第l个元素之前插入删掉的元素：就找到r删除，然后调整各个块的结构（对于[block[l]+1,block[r]]中的每个块，把它之前一块的最后一个元素移到自身块的第一个元素），然后找到l应该插入的位置并插入l

修改的同时，维护一下各个块中各个元素出现的次数

查询应该没什么问题了。。。

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<vector>
 using namespace std;
 #define fi first
 #define se second
 #define mp make_pair
 #define pb push_back
 typedef long long ll;
 typedef unsigned long long ull;
 typedef pair<int,int> pii;
 const int bs=;
 int cnt;//块数
 struct E
 {
     int pre,nxt;int d;
 }e[];
 int he[],ta[];//head,tail
 int bl[],st[],ed[];
 int num[][];
 void add_tail(int b,int x)
 {
     if(!ta[b])
     {
         he[b]=ta[b]=x;
     }
     else
     {
         e[ta[b]].nxt=x;e[x].pre=ta[b];
         ta[b]=x;
     }
     ++num[b][e[x].d];
 }
 int remove_tail(int b)
 {
     int t=ta[b];
     --num[b][e[t].d];
     if(he[b]==ta[b])
     {
         he[b]=ta[b]=;
     }
     else
     {
         ta[b]=e[t].pre;
         e[e[t].pre].nxt=;e[t].pre=;
     }
     return t;
 }
 void add_head(int b,int x)
 {
     if(!he[b])
     {
         he[b]=ta[b]=x;
     }
     else
     {
         e[he[b]].pre=x;e[x].nxt=he[b];
         he[b]=x;
     }
     ++num[b][e[x].d];
 }
 void ins_before(int b,int x,int y)//ins x to b before y
 {
     if(!he[b])
     {
         he[b]=ta[b]=x;
     }
     else if(y==he[b])
     {
         e[y].pre=x;
         e[x].nxt=y;
         he[b]=x;
     }
     else if(!y)
     {
         e[ta[b]].nxt=x;
         e[x].pre=ta[b];
         ta[b]=x;
     }
     else
     {
         e[e[y].pre].nxt=x;
         e[x].pre=e[y].pre;
         e[y].pre=x;
         e[x].nxt=y;
     }
 }
 int qq;
 int n,an,lans;
 int main()
 {
     //freopen("/tmp/YALI(10-23)/sample/queue/queue1.in","r",stdin);
     //freopen("/tmp/YALI(10-23)/sample/queue/queue1.out","w",stdout);
     int i,j,t,l,r,x,nl,nr,nt,b,idx;
     scanf("%d",&n);
     for(i=;i<=n;i++)
     {
         scanf("%d",&t);
         bl[i]=(i-)/bs;
         e[i].d=t;
     }
     cnt=(n-)/bs;
     for(i=;i<cnt;i++)
     {
         st[i]=bs*i+;
         ed[i]=bs*(i+);
     }
     st[cnt]=bs*cnt+;ed[cnt]=n;
     for(i=;i<=n;i++)    add_tail(bl[i],i);
     scanf("%d",&qq);
     while(qq--)
     {
         scanf("%d",&idx);
         if(idx==)
         {
             scanf("%d%d",&l,&r);
             l=(l+lans-)%n+;
             r=(r+lans-)%n+;
             if(l>r)    swap(l,r);
             /*
             if(bl[l]==bl[r])
             {
                 b=bl[r];
                 nr=he[b];
                 for(j=st[b]+1;j<=r;j++)
                     nr=e[nr].nxt;

             }
             else
             */
             {
                 b=bl[r];
                 nr=he[b];
                 for(j=st[b]+;j<=r;j++)
                     nr=e[nr].nxt;
                 if(nr==he[b])    he[b]=e[nr].nxt;
                 else    e[e[nr].pre].nxt=e[nr].nxt;
                 if(nr==ta[b])    ta[b]=e[nr].pre;
                 else    e[e[nr].nxt].pre=e[nr].pre;
                 e[nr].pre=e[nr].nxt=;
                 --num[b][e[nr].d];
                 b=bl[l];
                 for(j=bl[r];j>b;j--)
                 {
                     nt=remove_tail(j-);
                     add_head(j,nt);
                 }
                 if(l==ed[b])
                 {
                     nl=;
                 }
                 else
                 {
                     nl=ta[b];
                     for(j=ed[b]-;j>=l;j--)
                         nl=e[nl].pre;
                 }
                 ins_before(b,nr,nl);
                 ++num[b][e[nr].d];
             }
         }
         else
         {
             scanf("%d%d%d",&l,&r,&x);
             l=(l+lans-)%n+;
             r=(r+lans-)%n+;
             x=(x+lans-)%n+;
             if(l>r)    swap(l,r);
             an=;
             if(bl[l]==bl[r])
             {
                 b=bl[l];
                 nl=he[b];
                 for(j=st[b]+;j<=l;j++)
                     nl=e[nl].nxt;
                 for(j=l;j<=r;j++)
                 {
                     an+=(e[nl].d==x);
                     nl=e[nl].nxt;
                 }
             }
             else
             {
                 for(j=bl[l]+;j<=bl[r]-;j++)
                     an+=num[j][x];
                 b=bl[r];
                 nr=he[b];
                 an+=(e[nr].d==x);
                 for(j=st[b]+;j<=r;j++)
                 {
                     nr=e[nr].nxt;
                     an+=(e[nr].d==x);
                 }
                 b=bl[l];
                 nl=ta[b];
                 an+=(e[nl].d==x);
                 for(j=ed[b]-;j>=l;j--)
                 {
                     nl=e[nl].pre;
                     an+=(e[nl].d==x);
                 }
             }
             lans=an;
             printf("%d\n",an);
         }
     }
     return ;
 }

2.分块，定期重构（官方题解）

跟方法1大部分一样，但是块内不用链表，直接用vector或者数组，插入/删除就暴力，同时维护各个块中各个元素出现次数，然后每sqrt(n)次重构所有块

3.平衡树（见官方题解下面的第一条评论）

（额外解释：为什么是n*log^2而不是n*log呢？因为所有的下标都是动态的。询问(l,r,k)时，需要在k-splay中找出有多少个点下标在[l,r]内，而每一次查询下标必须要在0-splay中查询一下（注意下标是动态的，不能直接记下下标））

---

http://210.33.19.103/contest/1025/problem/3

此题同C.queue