数据结构专题 - 解题报告 - E

做到E题，要求统计区间内的众数出现了几次。
区间内的统计，自然想到线段树，那么有没有一种数据结构，能满足不同区间都能有一棵树可供查询呢？？我们很容易想到，主席树 (然而不是正解) ！设查询区间为 l 到 r ，那么 r 时的主席树与 l - 1 时的状态差就是区间内子树，然后区间内子树查询，完事。

首先遇到的一个难题，便是……我基本不熟主席树，之前也只是见过板子学过皮毛，于是还得挣扎学习，从下午到晚上，搞出来的主席树解法终于是能过样例。但是交上去却在11点惨遭碰壁。后面无论我如何优化我的树也过不了（其实是我也不会怎么优化），凌晨2点，我总算放弃了这个解法。这个200ms，看上去真的很恐怖。

然后我突然想到，如果是事先预处理过，再查询的话，在时间上就有极大的优势，借鉴以前搞过洛谷上的st表的模板题 ，有的测试点要求时限是100ms，那么有没有可能用倍增优化分块的思想处理出来呢？当天已经很晚了，所以没去尝试，后来听说这题有原题，我一看这题与bzoj 2724 蒲公英 如出一辙，网上也铺天盖地的题解，拜读过后总结就是分块并预处理，然后我第二天尝试的自写倍增分块始终没办法实现，所以还是借鉴了各路题解的思路，开方分块就好。做法如下：

读入，因为这题也只需要数字间的相对大小关系，为了节约数组空间，先离散化，离散化的过程中记下每个数字在原串内出现的位置，用vector数组( v[ ] )存储即可，然后数组的大小即为数字总共出现的次数，在用一个数组( 我用的id[ ] )存下每一个数字在vector内的位置。

然后是分块预处理，每一个板块大小( divlen )设定在略小于 sqrt( maxn ) 即可，我们需要计算出 n 个数字需要板块的数量( divnum )，和每个数字处于哪个板块( bel [ ] )，然后设定每个板块的左端点和右端点( l[ ] 和 r[ ] )。有了这些我们就可以开始计算从板块1到板块divnum间的所有板块最值( MAX [ ] [ ] )。如何求？遍历找最大值即可，因为有过分块，预处理的复杂度便是不过O(n√n)，并且这里常数极小。

最后就是单纯的查询了，两种情况，一种是仅在所求区间仅在板块内部，一种是跨板块，前者仅在一个板块内循环遍历就可以出来了，O(√n)，后者则是先记下跨过区间板块的计量数( ans )，再分别累计左右边路区间得出答案。在学习别人的解法的时候，发现一招非常精髓。

FOR(i, ql, r[lb])       //边界板块
	{
        int num = a[i], siz = v[num].size(), pos = id[i];   
        while((pos+ans) < siz && v[num][pos+ans] <= qr;
        	ans++;
    }
/*
意思是左区间内，
只要这个元素加上当前的ans，大小没有超出vector存储过的数量，
并且v中映射出这个元素范围在查询的qr内部，
那么ans就可以++，不管当前是什么元素。
这个操作爽到，记笔记记笔记。
*/

单次跨板块查询时间复杂度为2*O(√n)+O(1)，所以整个查询复杂度就是O(m√n)。
这应该就能满足正解的要求了吧。

---

AC代码如下：

#include<bits/stdc++.h>
#define maxn 40005
#define maxm 200005
#define FOR(a, b, c) for(int a=b; a<=c; a++)
#define hrdg 1000000007
#define inf 2147483647
#define llinf 9223372036854775807
#define ll long long
#define pi acos(-1.0)
#define ls p<<1
#define rs p<<1|1
#define max(a, b) a>b?a:b
using namespace std;
const int divlen = 180;    //分块长度略小于sqrt(maxn)
const int mdiv = maxn/divlen + 5;

int pre_lsh[maxn], a[maxn], a1[maxn], temp, ans;		
int n, m, ql, qr, lb, rb, l[maxn], r[maxn], bel[maxn], tot, divnum;
int id[maxn];
vector<int> v[maxn];
int cnt[maxn], MAX[mdiv][mdiv];

inline int read(){
    char c=getchar();long long x=0,f=1;
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}

void discret(){    //离散化
    sort(pre_lsh+1, pre_lsh+1+n);
    tot = unique(pre_lsh+1, pre_lsh+1+n) - (pre_lsh+1);
    FOR(i, 1, n)
    {
        a[i] = lower_bound(pre_lsh+1, pre_lsh+1+tot, a1[i]) - pre_lsh;
        id[i] = v[a[i]].size();     //id[i]该数在vector中的位置
        v[a[i]].push_back(i);       //vector存储每种数出现位置
    }
}

int main()
{
    n = read();				//读入
    m = read();
    FOR(i, 1, n)
    {
        a1[i] = read();
        pre_lsh[i] = a1[i];
        bel[i] = (i-1) / divlen + 1;
    }
    divnum = bel[n];    //分块数量
    
    discret();			//必要的离散化，极大节约数组空间，不然的话我的CEF都过不了
    
    FOR(i, 1, divnum)
    {
        l[i] = (i-1) * divlen;          //每个板块起始位置
        r[i] = l[i] + divlen - 1;       //结束位置
    }
    l[1] = 1; r[divnum] = n;
    FOR(i, 1, divnum)
    {
        memset(cnt, 0, sizeof(cnt));
        int mama = 0, now = i;
        FOR(j, l[i], n)
        {
            cnt[a[j]]++;                //线性数过去
            mama = max(mama, cnt[a[j]]);
            if(j == r[now])
            {
                MAX[i][now] = mama;
                now++;
            }
        }
    }
    while(m--)
    {
        ql = read(); qr = read();
        ql = (ql + ans - 1) % n + 1;
        qr = (qr + ans - 1) % n + 1;
        if(ql > qr) swap(ql, qr);			//按照题意处理查询的左边界和右边界
       
        lb = bel[ql], rb = bel[qr];
        ans = 0;
        if(lb == rb)        //同一分块内
        {
            FOR(i, ql, qr)
            {
                int num = a[i], siz = v[num].size(), pos = id[i];
                while(pos + ans < siz && v[num][pos+ans] <= qr)
                    ans++;
            }
        }
        else
        {
            if(lb + 1 < rb)         //先统计中间板块中预处理过的众数大小
                ans = MAX[lb+1][rb-1];
            FOR(i, ql, r[lb])       //边界板块
            {
                int num = a[i], siz = v[num].size(), pos = id[i];
                while((pos+ans) < siz && v[num][pos+ans] <= qr)
                    ans++;
            }
            FOR(i, l[rb], qr)
            {
                int num = a[i], pos = id[i];
                while(pos >= ans && v[num][pos-ans] >= ql)
                    ans++;
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}

/*
8 3
1 7 1 1 6 8 4 2
6 8
8 8
2 4
*/

总结一下吧，好题！也着实苦手。反正我也是自闭了两三天才做出来的(隔壁糖哥好像更惨)，在有题解提示和示范的前提下倒是能过，自己想的话我应该是跪了，想不到暴力和主席树以外的解法，即使有，我自己意淫的那个倍增处理也实现不来，唉。积累吧，集训队大爷把此题放在作业里作为分块教程是真的给人上了一课。

最后顺便提一下F题，我怎么看这个E和F那么像呢，然后改改交了也过了，不过F没要求强制在线的话估计是要我们学莫队离线做吧，再说再说