RMQ（Range Minmum Query）学习

Range Minmum Query 是查询一个区间的最小值得算法，
复杂度为nlog(n),
区间最小值查询问题（Range Minimum Query，RMQ）
原理：
给出一个 n 个元素的数组 A1， A2， …， An，设计一个数据结构，支持查询操作 Query(L,R)：计算 min{AL,AL+1,…,AR}

令 d(i,j) 表示从 i 开始的，长度为 2^j 的一段元素中的最小值，则可以用递推的方法计算
d(i，j)：d(i，j) = min{d(i，j-1)，d(i+2^(j-1)，j-1)}，原理如图所示

注意 2j ≤ n，因此 d 数组的元素个数不超过 nlogn，而每一项都可以在常数时间计算完毕，故总时间为 O(nlogn)

    void RMQ_Init(void)   
    {  
        for(int i = 0; i < n; ++i) {  
            d[i][0] = A[i];  
        }  
        for(int j = 1; (1<<j) <= n; ++j) {  //1<<j表示的是区间大小
            for(int i = 0; i + (1<<j) - 1 <= n; i++) {  
                d[i][j] = min(d[i][j-1], d[i + (1<<(j-1))][j-1]);  
            }  //如果需要进行查询的数组输入是从1开始的，那么上面的i从1开始，后面的<改成<=
        }  
    }  

查询操作很简单，令 k 为满足 2k ≤ R-L+1 的最大整数，则以 L 开头、以 R 结尾的两个长度为 2k 的区间合起来即覆盖了查询区间 [L，R]

由于是取最小值，有些元素重复考虑了几遍也没关系，如图所示（注意，如果是累加，重复元素是不允许的）

    int RMQ(int L, int R)  
    {  
        int k = 0;  
        while((1<<(k+1)) <= R-L+1) {  
            ++k;  
        }  
        return min(d[L][k], d[R-(1<<k)+1][k]);  //查询的时候只能是用这个，因为不能超过这个区间

    }  

UVA 11235 Frequent values

我的：
题中给出的是一个排好了序的数列，然后要在给出的一段区间之内找出相同的数最多的个数。
先对数组进行处理，使之可以进行range minmum query操作。
因为排好了序，所以相同的元素都在一起，所以用value和count数组分别记录一下第几个不同的数的值，和第几个不同的相同的数的个数，得用一个val_count变量来记录有多少个不同的数。然后对每个数找到他的num,Left,Right,分别代表这个数是属于第几个不同的数，left，right代表与这个数相同数的范围。
然后，就相当于对count这个数组进行RMQ操作，不过由于有的相同的数不全部都在这个查询的范围，但是这些不完全在查询区间的数如果有的话就是在查询区间的两端，所以先对两端相同的元素的个数取出来，然后在对中间的所有的数的count数组进行RMQ操作，判断最大值，输出。

我的：

#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<limits.h>
#include<map>
#include<set>
#include<queue>
#include<string>
#include<cstring>
#include<iostream>

const int maxn=100000+10;

using namespace std;// Range Minmum Query

int value[maxn];//???i??????
int counts[maxn];//????????
int num[maxn];//????????????
int Left[maxn];//????????????????????
int Right[maxn];//??????????????????
int d[maxn][40];//?????i,???2^j??????????
int a[maxn];//?????
int val_count;//??????

void RMQ_Init()//???
{
    for(int i=1;i<=val_count;i++)
        d[i][0]=counts[i];
    for(int j=1;(1<<j) <=val_count;j++)
    {
        for(int i=1;i + (1<<j) -1 <=val_count; i++)
        {
            d[i][j] = max( d[i][j-1] , d[i+ (1<<(j-1))][j-1]);
        }
    }
}

int RMQ(int l,int r)
{
    int k=0;
    while( (1<<(k+1) ) <= r-l+1)
    {
        k++;
    }
    return max(d[l][k] , d[ r- (1<< k) +1][k]);
}

int main()
{
    int n,m;
    while(scanf("%d",&n)&&n)
    {
        memset(value,0,sizeof(value));
        memset(num,0,sizeof(num));
        memset(counts,0,sizeof(counts));
        memset(Left,0,sizeof(Left));
        memset(Right,0,sizeof(Right));
        memset(d,0,sizeof(d));
        scanf("%d",&m);
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        val_count=0;
        int t=0;
        for(int i=1;i<=n;i++)
        {
            if(i==1||a[i]!=a[i-1])
            {
                ++val_count;
                num[i]=val_count;
                value[val_count]=a[i];
                counts[val_count]++;
                t = i;
                Left[i]=i;
                Right[t]=i;;
            }
            else
            {
                counts[val_count]++;
                num[i]=val_count;
                Left[i]=t;
                ++Right[t];
                if(i==n||a[i] != a[i+1])
                {
                    for(int j=t;j<=i;j++)
                        Right[j]=Right[t];
                }
            }
        }
//        for(int i=1;i<=val_count;i++)
//            cout<<value[i]<<" "<<counts[i]<<endl;
//        for(int i=1;i<=n;i++)
//            cout<<Left[i]<<" "<<Right[i]<<endl;
//          for(int i=1;i<=n;i++)
//            cout<<num[i]<<"";
        RMQ_Init();
//        for(int j=0;(1<<j) <=val_count;j++)
//        {
//            for(int i=1;i+(1<<j)-1<=val_count;i++)
//            {
//                cout<<i<<" "<<i+(1<<j)<<" "<<d[i][j]<<"    ";
//            }
//            cout<<endl;
//        }
        for(int ii=1;ii<=m;ii++)
        {
            int l,r;
            scanf("%d%d",&l,&r);
            if(num[l]==num[r])
            {
                cout<<r-l+1<<endl;
                continue;
            }
            int ans=max(Right[l]-l+1 , r-Left[r]+1);
//            cout<<ans<<" ";
            l=num[l]+1;
            r=num[r]-1;
            if(l<=r)
            {
                ans=max( ans, RMQ(l,r));
//                cout<<RMQ(l,r)<<endl;
            }
            cout<<ans<<endl;
        }
    }
    return 0;
}