bzoj2724: [Violet 6]蒲公英（分块）

传送门

md调了一个晚上最后发现竟然是空间开小了……明明算出来够的……

讲真其实我以前不太瞧得起分块，觉得这种基于暴力的数据结构一点美感都没有。然而今天做了这道分块的题才发现分块的暴力之美（如果我空间没有开小就更美了）

我们先将整个数组分块，设块的大小为$T$

我们先预处理出所有以块边界为端点的区间的答案，即$ans[L][R]$代表着第$L$块到第$R$块的序列所代表的答案。这个可以$O(n*n/T)$预处理

然后我们先将所有的数给离散化，然后对每一个值都开一个vector，记录这个值在数组中出现的每一个位置。比如数组的下标为1,3,5的位置都是3，那么3的vector记录的就是{1,3,5}

这个有什么用呢？我们设查询的区间为$[l,r]$，然后在这个vector里先二分查找第一个大于等于$l$的数的位置，再二分查找第一个大于$r$的数的位置，那么两个位置一减就是这个数在这个区间中的出现次数。比如查询区间$[2,4]$，我们先找到第一个大于等于2的数3，在vector中下标为2，再找第一个大于4的数为5，下标为3，那么3-2=1就是3这个数字在这个区间中的出现次数

那么，我们设$[L,R]$为查询区间之间的整块，因为我们第一步已经预处理出了所有块与块之间的答案，那么这一段之间的众数也就可以知道。那么，只有区间$[l,L-1]$和$[R+1,r]$之间的数字有可能更新答案。那么我们就去枚举这两个区间中的所有数字，然后用上面说的方法去查询它在整个查询区间内的出现次数，然后更新答案即可

复杂度为$O(n*n/T+n*T*logn)$，设块的大小为$n/sqrt{nlogn}$ ，那么时间复杂度就是$O(nsqrt{nlogn})$

其实还有一种更快的方法是先预处理出块与块之间的答案和各个数的出现次数，然后查询只要在散块里暴力增加并更新答案，之后暴力复原即可（然而我懒并不想打）

然后基本注意点都写在注解里了

//minamoto
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
#include<cmath>
#define inf 0x3f3f3f3f
using namespace std;
#define getc() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++)
char buf[1<<21],*p1=buf,*p2=buf;
inline int read(){
    #define num ch-'0'
    char ch;bool flag=0;int res;
    while(!isdigit(ch=getc()))
    (ch=='-')&&(flag=true);
    for(res=num;isdigit(ch=getc());res=res*10+num);
    (flag)&&(res=-res);
    #undef num
    return res;
}
char sr[1<<21],z[20];int C=-1,Z;
inline void Ot(){fwrite(sr,1,C+1,stdout),C=-1;}
inline void print(int x){
    if(C>1<<20)Ot();if(x<0)sr[++C]=45,x=-x;
    while(z[++Z]=x%10+48,x/=10);
    while(sr[++C]=z[Z],--Z);sr[++C]='\n';
}
const int N=40005,M=1005;
int ans[M][M],a[N],b[N],cnt[N],rt[N],vis[N];
vector<int> pos[N];
int n,m,q,lastans=0,s,l,r;
inline int query_cnt(int x){
    //查询数的出现次数，注意l和r要开全局变量 
    return upper_bound(pos[x].begin(),pos[x].end(),r)-lower_bound(pos[x].begin(),pos[x].end(),l);
}
void init(){
    //暴力枚举块与块之间的答案 
    for(int i=1;i<=rt[n];++i){
        memset(cnt,0,sizeof(cnt));
        int bg=s*(i-1)+1,res=a[bg];
        for(int j=bg;j<=n;++j){
            ++cnt[a[j]];
            if(cnt[a[j]]>cnt[res]||(cnt[a[j]]==cnt[res]&&a[j]<res)) res=a[j];
            ans[i][rt[j]]=res;
        }
    }
}
int query(int l,int r){
    //查询，小块暴力，大块直接找答案 
    if(rt[r]-rt[l]<=1){
        int id=0,res=0;
        for(int i=l;i<=r;++i)
        if(!vis[a[i]]){
            int t=query_cnt(a[i]);
            if(t>res||(t==res&&a[i]<id)) res=t,id=a[i];
            vis[a[i]]=1;
        }
        for(int i=l;i<=r;++i) vis[a[i]]=0;
        return b[id];
    }
    int L=rt[l]+1,R=rt[r]-1;
    int LL=(L-1)*s+1,RR=R*s;
    int id=ans[L][R],res=query_cnt(id);vis[id]=1;
    for(int i=l;i<LL;++i)
    if(!vis[a[i]]){
        int t=query_cnt(a[i]);
        if(t>res||(t==res&&a[i]<id)) res=t,id=a[i];
        vis[a[i]]=1;
    }
    for(int i=RR+1;i<=r;++i)
    if(!vis[a[i]]){
        int t=query_cnt(a[i]);
        if(t>res||(t==res&&a[i]<id)) res=t,id=a[i];
        vis[a[i]]=1;
    }
    for(int i=l;i<LL;++i) vis[a[i]]=0;
    for(int i=RR+1;i<=r;++i) vis[a[i]]=0;
    vis[ans[L][R]]=0;
    return b[id];
}
int main(){
    n=read(),q=read(),s=sqrt(n/(double)(log2(n))+1);
    //我怕s会变成0所以sqrt里加了个1（可能并不需要） 
    for(int i=1;i<=n;++i) a[i]=b[i]=read(),rt[i]=(i-1)/s+1;//分块 
    sort(b+1,b+1+n),m=unique(b+1,b+1+n)-b-1;
    for(int i=1;i<=n;++i) a[i]=lower_bound(b+1,b+1+m,a[i])-b,pos[a[i]].push_back(i);
    //以上是离散 
    init();
    while(q--){
        l=read(),r=read();
        l=(l+lastans-1)%n+1,r=(r+lastans-1)%n+1;
        if(l>r) swap(l,r);
        print(lastans=query(l,r));
    }
    Ot();
    return 0;
}