RMQ

RMQ

RMQ（Range Minimum/Maximum Query），即区间最值查询，这是一种在线算法，所谓在线算法，是指用户每次输入一个查询，便马上处理一个查询。RMQ算法一般用较长时间做预处理，时间复杂度为O(nlogn)，然后可以在O（1）的时间内处理每次查询。

下面我们从一个实际问题来解释RMQ

我们假设数组arr为：1，3，6，7，4，2，5

我们设二维数组dp[i][j]表示从第i位开始连续2^j个数中的最小值。例如dp[2][1]就表示从第二位数开始连续两个数的最小值（也就是从第二位数到第三位数的最小值），即3，6中的最小值，所以dp[2][1] = 3;

其实我们求 dp[i][j] 的时候可以把它分成两部分，第一部分是从 i 到 i + 2 ^( j-1 ) - 1 ，第二部分从 i + 2 ^( j-1 ) 到i + 2^j -1 ，为什么可以这么分呢？其实我们都知道二进制数前一个数是后一个的两倍，那么可以把 i ~ i + 2^j -1 这个区间 通过2^(j-1) 分成相等的两部分， 那么转移方程很容易就写出来了。（dp[i][0]就表示第i个数字本身）

dp[i][j] = min(dp [i][j - 1], dp [i + (1 << j - 1)][j - 1])

由此给出下列代码：

void rmq_init()
{
    for(int i=1;i<=N;i++)
        dp[i][0]=arr[i];//初始化
    for(int i=1;(1<<i)<=N;i++)
        for(int j=1;j+(1<<i)-1<=N;j++)
            dp[j][i]=min(dp[j][i-1],dp[j+(1<<i-1)][i-1]);
}

这里需要注意一个循环变量的顺序，我们看到外层循环变量为j，内层循环变量为i，这是为什么呢？可以互换一下位置吗？

答案当然是不可以，我们要理解这个状态转移方程的意义，这个状态方程的含义是：先更新每两个元素中的最小值，然后通过每两个元素的最小值获得每4个元素中的最小值，依次类推更新所有长度的最小值。

而如果是i在外，j在内的话，我们更新的顺序就变成了从1开始的前1个元素，前2个元素，前4个元素，前8个元素。。。

当j等于3的时候dp[1][3]=min(min(ans[0],ans[1],ans[2],ans[3]),min(ans[4],ans[5],ans[6],ans[7])))的值，

但是我们根本没有计算min(ans[0],ans[1],ans[2],ans[3])和min(ans[4],ans[5],ans[6],ans[7])，所以这样的方法肯定是错误的。

为了避免这样的错误，一定要好好理解这个状态转移方程所代表的含义。

加深理解：
例如：

A数列为：3 2 4 5 6 8 1 2 9 7

F[1，0]表示第1个数起，长度为2^0=1的最大值，其实就是3这个数。同理 F[1,1] = max(3,2) = 3, F[1，2]=max(3,2,4,5) = 5，F[1，3] = max(3,2,4,5,6,8,1,2) = 8;

并且我们可以容易的看出F[i,0]就等于A[i]。（DP的初始值）

我们把F[ i，j ]平均分成两段（因为F[ i，j ]一定是偶数个数字），从 i 到i + 2 ^ (j - 1) - 1为一段，i + 2 ^ (j - 1)到i + 2 ^ j - 1为一段(长度都为2 ^ (j - 1))。于是我们得到了状态转移方程F[ i , j ]=max（F[ i，j-1 ], F[ i + 2^(j-1)，j-1 ]）。

接下来我们来讲解RMQ的查询部分，假设我们需要查询区间[l ，r]中的最小值，令k = log2(r - l + 1); 则区间[l, r]的最小值RMQ[l,r] = min(dp[l][k], dp[r - (1 << k) + 1][k]);

但是为什么这样就可以保证是区间最小值了呢？

mn[l][k]维护的是[l, l + 2 ^ k - 1], mn[r - (1 << k) + 1][k]维护的是[r - 2 ^ k + 1, r] 。

那么只要我们保证r - 2 ^ k + 1 <= l + 2 ^ k - 1就能保证RMQ[l,r] = min(dp[l][k], dp[r - (1 << k) + 1][k])；

接下来我们用分析法来证明这个不等式：

我们假设 r - 2^k +1 <= l + 2^k -1 这个等式成立

即有 r - l + 2 <= 2^(k+1) 也就是 r - l + 2 <= 2 * 2^k

又因为 k =log2 (r- l + 1);

那么 r - l + 2 <= 2 * (r - l +1)

则 r - l + 2 <= 2*(r - l) + 2

所以 r - l >= 0 所以假设成立

我们举个栗子 l = 4，r = 6;

我们假设数组arr为：1，3，6，7，4，2，5

此时 k = log2( r - l + 1）= log2（3）=1

则dp[4][6] = min（dp[4][1],dp[5][1]）

dp[4][1] = 4，dp[5][1] = 2，所以dp[4][6] = min(dp[4][1],dp[5][1]) = 2

我们很容易看出来答案是正确的。

由此给出查询部分代码：

int rmq(int l,int r)
{
    int k=log2(r-l+1);
    return min(dp[l][k],dp[r-(1<<k)+1][k]);
}

RMQ算法，是一个快速求区间最值的离线算法，预处理时间复杂度O（n*log(n)），查询O(1)，所以是一个很快速的算法，当然这个问题用线段树同样能够解决。
1、求区间的最大值和最小值！

#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
using namespace std;
const int MAXN = 100117;
int n,query;
int num[MAXN];

int F_Min[MAXN][20],F_Max[MAXN][20];

void Init()
{
   for(int i = 1; i <= n; i++)
   {
       F_Min[i][0] = F_Max[i][0] = num[i];
   }

   for(int i = 1; (1<<i) <= n; i++)  //按区间长度递增顺序递推
   {
       for(int j = 1; j+(1<<i)-1 <= n; j++)  //区间起点
       {
           F_Max[j][i] = max(F_Max[j][i-1],F_Max[j+(1<<(i-1))][i-1]);
           F_Min[j][i] = min(F_Min[j][i-1],F_Min[j+(1<<(i-1))][i-1]);
       }
   }
}

int Query_max(int l,int r)
{
   int k = (int)(log2(double(r-l+1)));
   return max(F_Max[l][k], F_Max[r-(1<<k)+1][k]);
}

int Query_min(int l,int r)
{
   int k = (int)(log2(double(r-l+1)));
   return min(F_Min[l][k], F_Min[r-(1<<k)+1][k]);
}

int main()
{
   int a,b;
   scanf("%d %d",&n,&query);
   for(int i = 1; i <= n; i++)
       scanf("%d",&num[i]);
   Init();
   while(query--)
   {
       scanf("%d %d",&a,&b);
       printf("区间%d到%d的最大值为：%d\n",a,b,Query_max(a,b));
       printf("区间%d到%d的最小值为：%d\n",a,b,Query_min(a,b));
       printf("区间%d到%d的最大值和最小值只差为：%d\n",a,b,Query_max(a,b)-Query_min(a,b));
   }
   return 0;
}

2、求区间内出现次数最多的数字出现的次数！
对上升序列如：1 1 2 2 2 3 3 4 5 5 … 统计区间出现次数最多数个数。

我们可以构造一个b[]数组，

if（a[i]==a[i-1]）b[i]=b[i-1]+1;

else b[i]=1;

这样对上述例子，b[]数组有1 2 1 2 3 1 2 1 1 2

那么对询问区间[l,r]，如果l在数与数交界处，那么直接查询l,r区间最大值。

否则要知道与a[l]相同延伸到end，那么这个区间大小end-l+1，与rmq(end+1，r)取最大值就是答案。

#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
 
const int maxn = 100017;
int num[maxn], f[maxn], MAX[maxn][20];
int n;
int max(int a,int b)
{
    return a>b ? a:b;
}
int rmq_max(int l,int r)
{
    if(l > r)
        return 0;
    int k = log2((double)(r-l+1));
    return max(MAX[l][k],MAX[r-(1<<k)+1][k]);
}
void init()
{
    for(int i = 1; i <= n; i++)
    {
        MAX[i][0] = f[i];
    }
    int k = log2((double)(n+1));
    for(int i = 1; i <= k; i++)
    {
        for(int j = 1; j+(1<<i)-1 <= n; j++)
        {
            MAX[j][i] = max(MAX[j][i-1],MAX[j+(1<<(i-1))][i-1]);
        }
    }
}
int main()
{
    int a, b, q;
    while(scanf("%d",&n) && n)
    {
        scanf("%d",&q);
        for(int i = 1; i <= n; i++)
        {
            scanf("%d",&num[i]);
        }
        sort(num+1,num+n+1);
        for(int i = 1; i <= n; i++)
        {
            if(i == 1)
            {
                f[i] = 1;
                continue;
            }
            if(num[i] == num[i-1])
            {
                f[i] = f[i-1]+1;
            }
            else
            {
                f[i] = 1;
            }
 
        }
 
        init();
 
        for(int i = 1; i <= q; i++)
        {
            scanf("%d%d",&a,&b);
            int t = a;
            while(t<=b && num[t]==num[t-1])
            {
                t++;
            }
            int cnt = rmq_max(t,b);
            int ans = max(t-a,cnt);
            printf("%d\n",ans);
        }
    }
    return 0;
}
/*
10 3
-1 -1 1 2 1 1 1 10 10 10
2 3
1 10
5 10
*/