Serega and Fun Codeforces

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=300;
int cnt;//块数
struct E
{
    int pre,nxt;int d;
}e[100100];
int he[355],ta[355];//head,tail
int bl[100100],st[355],ed[355];
int num[355][100100];
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]=0;
    }
    else
    {
        ta[b]=e[t].pre;
        e[e[t].pre].nxt=0;e[t].pre=0;
    }
    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=1;i<=n;i++)
    {
        scanf("%d",&t);
        bl[i]=(i-1)/bs;
        e[i].d=t;
    }
    cnt=(n-1)/bs;
    for(i=0;i<cnt;i++)
    {
        st[i]=bs*i+1;
        ed[i]=bs*(i+1);
    }
    st[cnt]=bs*cnt+1;ed[cnt]=n;
    for(i=1;i<=n;i++)    add_tail(bl[i],i);
    scanf("%d",&qq);
    while(qq--)
    {
        scanf("%d",&idx);
        if(idx==1)
        {
            scanf("%d%d",&l,&r);
            l=(l+lans-1)%n+1;
            r=(r+lans-1)%n+1;
            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]+1;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=0;
                --num[b][e[nr].d];
                b=bl[l];
                for(j=bl[r];j>b;j--)
                {
                    nt=remove_tail(j-1);
                    add_head(j,nt);
                }
                if(l==ed[b])
                {
                    nl=0;
                }
                else
                {
                    nl=ta[b];
                    for(j=ed[b]-2;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-1)%n+1;
            r=(r+lans-1)%n+1;
            x=(x+lans-1)%n+1;
            if(l>r)    swap(l,r);
            an=0;
            if(bl[l]==bl[r])
            {
                b=bl[l];
                nl=he[b];
                for(j=st[b]+1;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]+1;j<=bl[r]-1;j++)
                    an+=num[j][x];
                b=bl[r];
                nr=he[b];
                an+=(e[nr].d==x);
                for(j=st[b]+1;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]-1;j>=l;j--)
                {
                    nl=e[nl].pre;
                    an+=(e[nl].d==x);
                }
            }
            lans=an;
            printf("%d
",an);
        }
    }
    return 0;
}

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