RMQ

范围最小值问题（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)};原理图如下：

  注意2^j<=n；所以d数组的元素个数不超过nlogn，而每一项都可以在常数时间内计算完成，故总时间为O(nlogn)，代码如下：

void RMQ_init(int n)
{
	for(int i=0;i<n;i++)
		d[i][0]=A[i];
	for(int j=1;(1<<j)<=n;j++)
		for(int i=0;i+(1<<j)-1<n;i++)
			d[i][j]=max(d[i][j-1],d[i+(1<<j-1)][j-1]);
}

 查询操作很简单，令k为满足2^k<=R-L+1最大整数，则以L开头以R结尾的两个长度为2^k的区间合起来即覆盖了查询区间（L,R），由于取的是最小值重复考虑几遍也没关系

原理图：

   代码：

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]);
}

  这样在 O(nlogn)的预处理下，做到了O(1)的查询时间。

例题：

频繁出现的数值（UVA11235）

先把题目给出的非降序序列变成计数的形式，比如-1 -1 1 1 1 1 3 10 10 10，变成2 4 1 3；

因为题目不是直接问你第几段到第几段，而是给你两个下标L,R，要你求最大值，所以你要记录一下每个下标对应的段的下标。

比如以上的序列就要变成1 1 2 2 2 2 3 4 4 4；

然后由于题目问你的时候，给你的下标不会恰好就是左边段的起始点和右边段的结束点；

所以，要把一个询问拆成三小块：

1.L到L对应段的最右有多少元素；

2.R到R对应段的最左有多少元素；

3.L对应段右边第一个段，和R对应段左边第一个段，之间最大为多少。

那么只要把RMQ的求最小值变为求最大值就可以求出来了。

代码：

#include <iostream>
using namespace std;
struct node{
	int value;
	int count;
	int l;
	int r;
}no[100000];
int num[100000],vis[100000];
int d[100000][20];
int max(int a,int b)
{
	return (a>b)?a:b;
}
int max3(int a,int b,int c)
{

	return max(c,max(a,b));
}

void RMQ_init(int n)
{
	for(int i=0;i<n;i++)
		d[i][0]=no[i].count;
	for(int j=1;(1<<j)<=n;j++)
		for(int i=0;i+(1<<j)-1<n;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;
	if(L>R)
		return -1;
	while((1<<(k+1))<=R-L+1) k++;
	return max(d[L][k],d[R-(1<<k)+1][k]);
}
int main()
{
	int n,t;
	while(cin>>n&&n)
	{
		cin>>t;
		int k=0;
		no[k].l=1;
		no[k].count=1;
		cin>>num[1];
		vis[1]=k;
		for(int i=2;i<=n;i++)
		{
			cin>>num[i];

            if(num[i]==num[i-1])
			{
				no[k].count++;
			}
			else
			{
				no[k].r=i-1;
				no[k].value=num[i-1];
				no[++k].l=i;
				no[k].count=1;
			}
			vis[i]=k;
		}
		if(num[n]==num[n-1])
		{
			no[k].r=n;
			no[k].value=num[n];
		}
		int cnt=k+1;
		int L,R;
		RMQ_init(cnt);
		while(t--)
		{
			cin>>L>>R;
			if(num[L]==num[R])
			{
				cout<<R-L+1<<endl;
			}
			else
			{
			    //int i1;
				//for(i1=0;i1<cnt;i1++)
                //   if(num[L]==no[i1].value)
				//	   break;
				int m1=(no[vis[L]].r-L+1);
				//int j1;
				//for(j1=i1+1;j1<cnt;j1++)
				  // if(num[R]==no[j1].value)
				//	   break;
                int m2=R-no[vis[R]].l+1;

				int m3=RMQ(vis[L]+1,vis[R]-1);
				cout<<max3(m1,m2,m3)<<endl;
			}
		}
	}
	return 0;
}