区间最小众数

/**
数列分块9
链接:https://loj.ac/problem/6285
查询区间最小众数;
首先离散化一下比较方便。
最小众数:完整的所有块的众数,和不完整块中出现的数。
所以我们可以预处理dp(i,j)表示第 i 块到第 j 块的众数 n*sqrt(n)
那么只要能快速得出一个数在某个区间内出现次数即可，每次只要比较至多2√n+1个元素的出现次数，这题就解决了。
由于没有修改，只要离散化以后，给每个数 x 开个vector；
按顺序存下x出现的位置;
每次询问 x 时把区间的左右端点放进对应 vector 二分一下即可。
具体细节  看注释........2018 7/27 
*/
 
#include<bits/stdc++.h>
#define ll long long
using namespace std;
 
/**********************************************Head-----Template****************************************/
bool Finish_read;
template<class T>inline void read(T &x){Finish_read=0;x=0;int f=1;char ch=getchar();while(!isdigit(ch)){if(ch=='-')f=-1;if(ch==EOF)return;ch=getchar();}while(isdigit(ch))x=x*10+ch-'0',ch=getchar();x*=f;Finish_read=1;}
template<class T>inline void print(T x){if(x/10!=0)print(x/10);putchar(x%10+'0');}
template<class T>inline void writeln(T x){if(x<0)putchar('-');x=abs(x);print(x);putchar('\n');}
template<class T>inline void write(T x){if(x<0)putchar('-');x=abs(x);print(x);}
ll gcd(ll a,ll b){return b==0?a:gcd(b,a%b);}
ll lcm(ll a,ll b){ll gg=gcd(a,b);a/=gg;if(a<=LLONG_MAX/b) return a*b;return LLONG_MAX;}
/********************************Head----Temlate**********************************************/
 
const int maxn=1e5+7;
vector<int>vec[maxn];
map<int,int>mp;
 
int id,n,m;
int dp[1000][1000];
int cnt[maxn],s[maxn];
int val[maxn],pos[maxn];//记录最原始的位置
 
void pre(int x){//直接暴力预处理出第x块  到x-->pos[n]块的最小众数
    memset(cnt,0,sizeof(cnt));
    int mx=0,ans=0;
    for(int i=(x-1)*m+1;i<=n;i++){
        cnt[s[i]]++;
        int tmp=pos[i];
        if(cnt[s[i]]>mx||(cnt[s[i]]==mx&&val[s[i]]<val[ans])) ans=s[i],mx=cnt[s[i]];
        dp[x][tmp]=ans;//对于当前块到下面接下来的块的最小众数;
    }
}
 
int query(int l,int r,int x){ return upper_bound(vec[x].begin(),vec[x].end(),r)-lower_bound(vec[x].begin(),vec[x].end(),l); }
 
int query(int l,int r){
    int ans,mx;
    ans=dp[pos[l]+1][pos[r]-1];//完整块的查询 为完整块的最小众数;
    mx=query(l,r,ans);//完整块众数出现的次数
    //非完整块的查询;
    for(int i=l;i<=min(r,pos[l]*m);i++){
        int t=query(l,r,s[i]);//暴力枚举非完整块的每一个数 对l r 进行查询 s[i]的个数 并且不断更新
        if(t>mx||(t==mx&&val[s[i]]<val[ans])) ans=s[i],mx=t;
    }
    if(pos[l]!=pos[r]){
        for(int i=(pos[r]-1)*m+1;i<=r;i++){
            int t=query(l,r,s[i]);
            if(t>mx||(t==mx&&val[s[i]]<val[ans])) ans=s[i],mx=t;
        }
    }
    return ans;
}
 
void solved(){
    read(n);
    m=sqrt(n);//块的大小;
    for(int i=1;i<=n;i++) {
        read(s[i]);
        if(!mp[s[i]]){
            mp[s[i]]=++id; //离散化
            val[id]=s[i];  //val存储离散化之前的值
        }
        s[i]=mp[s[i]];
        vec[s[i]].push_back(i);
        /**
        算是反转思想吧
        将s[i]出现过的角标存储到对应的vector
        eg: 对于l r val 出现的次数 可以直接在  vec[val] 内进行二分查找 很奇妙的一个想法;
        想法类似于HDU 口算训练
        */
    }
    for(int i=1;i<=n;i++) pos[i]=(i-1)/m+1;
    for(int i=1;i<=pos[n];i++) pre(i);//预处理出第i块到后面块的最小众数;
    for(int i=1;i<=n;i++){
        int l,r;scanf("%d %d",&l,&r);
        if(l>r) swap(l,r);
        writeln(val[query(l,r)]);
    }
}
 
int main(){
    solved();
    return 0;
}