题目链接
大致意思就是给定一个非降序的序列，查询某个区间中出现最多的数字的出现次数。

分析：

既然是非降序的序列，那么相同的数字会出现在一起，所以直接记录相同的一段的起始和结束位置，比如一个序列：-1，-1，1，1，1，2，2，2可以用[1,2] [3,5] [6,8] 来记录，表示这三个区间的数字是一样的，区间长度就代表了数字出现的次数。
查询的时候先判断查询区间的左右端点位于哪一个区间，因此需要再定义一个数组pos来记录某个位置的数字属于哪个区间，pos[i]=j表示位置i是在第j个区间。
对于一个查询区间[L,R]，有两种情况：
1. 如果左右端点位于同一个区间，直接输出R-L+1即可。
2. 如果左右端点位于不同的区间，那么查询区间[L,R]可以分成三个子区间：从L到L所在的区间的右端点，中间的区间（可能有多段区间组成，取其中最长的），从R所在的区间的左端点到R。 找到这三个子区间中最长的输出。
在寻找中间区间的时候就可以用稀疏表来快速找到最多的数字出现次数了。
dp[i][j]表示第i个区间为起点，长度为2的j次方个区间中最长的区间长度。

具体见代码注释：

#include <bits/stdc++.h>
using namespace std;

struct node //区间结构体
{
    int length = 0; //区间长度
    int left;       //区间左端点
    int right;      //区间右端点
} nd[100005];
int data[100005], pos[100005], dp[100005][20];

int init_nd(int t) //区间预处理，返回区间个数
{
    int cnt = 0; //区间编号
    nd[0].left = 1;
    pos[0] = 0;
    for (int i = 2; i <= t; ++i)
    {
        //当前数字与之前不同，增加区间
        if (data[i] != data[nd[cnt].left])
        {
            nd[cnt].right = i - 1;
            nd[cnt].length = i - nd[cnt].left;
            cnt++;
            nd[cnt].left = i;
        }
        pos[i] = cnt;
    }
    nd[cnt].right = t;
    nd[cnt].length = nd[cnt].right - nd[cnt].left + 1;
    return cnt;
}

void init_dp(int length) //稀疏表预处理
{
    for (int i = 0; i < length; i++)
    {
        dp[i][0] = nd[i].length;
    }
    for (int k = 1; (1 << k) <= length; k++)
    {
        int len1 = 1 << k;
        int len2 = len1 >> 1;
        for (int j = length - len1; j >= 0; j--)
        {
            dp[j][k] = max(dp[j][k - 1], dp[j + len2][k - 1]);
        }
    }
}

int query(int l, int r) //稀疏表查询
{
    if (l > r)
        return -1;
    if (l == r)
        return dp[l][0];
    int len = r - l + 1;
    int k = 1;
    while ((2 << k) <= len) //找到k的最大值（2^k<=len）
        k++;
    return max(dp[l][k], dp[r + 1 - (1 << k)][k]);
}

int main()
{
    int t, n;
    while (cin >> t && t)
    {
        cin >> n;
        for (int i = 1; i <= t; ++i)
        {
            scanf("%d", &data[i]);
        }
        int cnt = init_nd(t);
        init_dp(cnt + 1);

        //处理区间查询
        int l, r;
        while (n--)
        {
            scanf("%d%d", &l, &r);
            if (pos[l] == pos[r]) //左右端点位于同一个区间
            {
                printf("%d\n", r - l + 1);
            }
            else //左右端点位于不同区间
            {
                int len1 = nd[pos[l]].right - l + 1;
                int len2 = r - nd[pos[r]].left + 1;
                int len3 = query(pos[l] + 1, pos[r] - 1); //如果l和r是相邻区间，那么len3=-1，对结果无影响
                printf("%d\n", max(max(len1, len2), len3));
            }
        }
    }
    return 0;
}