RMQ问题的三种解法

RMQ问题的三种解法

首先说一下什么是RMQ问题：

RMQ (Range Minimum/Maximum Query)问题是指：对于长度为n的数列A，回答若干询问RMQ(A,i,j)(i,j<=n)，返回数列A中下标在[i,j]里的最小(大）值，也就是说，RMQ问题是指求区间最值的问题 
主要方法及复杂度(处理复杂度和查询复杂度)如下: 
1.朴素（即搜索） O(n)-O(n) 
2.线段树(segment tree) O(n)-O(logn) 
3.ST（实质是动态规划） O(nlogn)-O(1) 

下面贴出一个例题：

题目描述：

给定一个数字序列，查询任意给定区间内数字的最小值。

输入：

输入包含多组测试用例，每组测试用例的开头为一个整数n(1<=n<=100000)，代表数字序列的长度。
接下去一行给出n个数字，代表数字序列。数字在int范围内。
下一行为一个整数t(1<=t<=10000)，代表查询的次数。
最后t行，每行给出一个查询，由两个整数表示l、r(1<=l<=r<=n)。

输出：

对于每个查询，输出区间[l,r]内的最小值。

样例输入：

5
3 2 1 4 3
3
1 3
2 4
4 5

样例输出：

1
1
3

解法一：直接搜索

#include<cstdio>
#define MAX 100010

int Getmin(int A[],int L,int R)
{
	int min=0x7FFFFFFF;
	int i;
	for(i=L;i<=R;i++)
		if(A[i]<min)
			min=A[i];
	return min;
}

int main(int argc,char *argv[])
{
	int n;
	int A[MAX];
	int i,T,L,R;
	int ans;
	while(scanf("%d",&n)!=EOF)
	{
		for(i=1;i<=n;i++)
			scanf("%d",&A[i]);
		scanf("%d",&T);
		while(T--)
		{
			scanf("%d%d",&L,&R);
			ans=Getmin(A,L,R);
			printf("%d\n",ans);
		}
	}

	return 0;
}

结果，理所当然超时（其实只有最后一个case超时）。。。

解法二：线段树

线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2+1,b]。因此线段树是平衡二叉树，最后的子节点数目为N，即整个线段区间的长度。使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN）。而未优化的空间复杂度为2N，因此有时需要离散化让空间压缩。

AC代码：

#include<cstdio>
#include<cmath>
#include<algorithm>
#define MAX 100010

typedef struct Node
{
	int l,r;
	int min;
}Node;

Node N[MAX*3];
int A[MAX];

int fmin(int a,int b)
{
	return a<b?a:b;
}

void BuildTree(int left,int right,int u)
{
	N[u].l=left;
	N[u].r=right;
	if(left==right)
	{
		N[u].min=A[left];
	}
	else
	{
		BuildTree(left,(left+right)>>1,2*u);
		BuildTree(((left+right)>>1)+1,right,2*u+1);
		N[u].min=(int)fmin(N[2*u].min,N[2*u+1].min);
	}
}

int query(int left,int right,int u)
{
	if(N[u].l==left&&N[u].r==right)
		return N[u].min;
	if(right<=N[2*u].r)
		return query(left,right,2*u);
	if(left>=N[2*u+1].l)
		return query(left,right,2*u+1);
	int mid=(N[u].l+N[u].r)>>1;
	return (int)fmin(query(left,mid,2*u),query(mid+1,right,2*u+1));
}

int main(int argc,char *argv[])
{
	int i,n,ans;
	int T,L,R;
	while(scanf("%d",&n)!=EOF)
	{
		for(i=1;i<=n;i++)
			scanf("%d",&A[i]);
		BuildTree(1,n,1);
		scanf("%d",&T);
		while(T--)
		{
			scanf("%d%d",&L,&R);
			ans=query(L,R,1);
			printf("%d\n",ans);
		}
	}

	return 0;
}

解法三：动态规划（这是要介绍的重点）

下面来看一下本算法的原理：

首先是预处理，用一个DP解决。设a[i]是要求区间最值的数列，f[i,j]表示从第i个数起连续2^j个数中的最大值。例如数列3 2 4 5 6 8 1 2 9 7 ,f[1，0]表示第1个数起，长度为2^0=1的最大值，其实就是3这个数。f[1，2]=5，f[1，3]=8，f[2，0]=2，f[2，1]=4……从这里可以看出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）)。用上例说明，当i=1，j=3时就是3,2,4,5 和 6,8,1,2这两段。f[i，j]就是这两段的最大值中的最大值。于是我们得到了动规方程F[i,j]=max（F[i，j-1],F[i+2^(j-1)，j-1]）.
接下来是得出最值，一个很好的办法，做到了O（1）。还是分开来。如在上例中我们要求区间[2，8]的最大值，就要把它分成[2,5]和[5,8]两个区间，因为这两个区间的最大值我们可以直接由f[2，2]和f[5，2]得到。扩展到一般情况，就是把区间[l，r]分成两个长度为2^k的区间（保证有f[i，j]对应）。直接给出表达式：
k:=(int)(log(r-l+1)/log(2))；
ans:=max(F[l，k]，F[r-2^k+1，k])；

AC代码：

#include<cstdio>
#include<cmath>
#include<algorithm>

#define MAXN 100010

using namespace std;
int dp[MAXN][40];

void RMQ(int A[],int n)
{
	int i,j;
	for(i=1;i<=n;i++)
		dp[i][0]=A[i];
	for(j=1;j<=(int)(log(n*1.0)/log(2.0));j++)
		for(i=1;i+(1<<j)-1<=n;i++)
			dp[i][j]=min(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
}

int query(int L,int R)
{
	int k=(int)((log(R-L+1)*1.0)/log(2.0));
	return min(dp[L][k],dp[R-(1<<k)+1][k]);
}

int main(int argc,char *argv[])
{
	int i,n,ans;
	int A[MAXN];
	int T,L,R;
	while(scanf("%d",&n)!=EOF)
	{
		for(i=1;i<=n;i++)
			scanf("%d",&A[i]);
		RMQ(A,n);
		scanf("%d",&T);
		while(T--)
		{
			scanf("%d%d",&L,&R);
			ans=query(L,R);
			printf("%d\n",ans);
		}
	}

	return 0;
}

很明显，三个算法中，动态规划算法最优，线段树次之，直接搜索效率最低。当然这不是绝对的，算法效率越高，其编写的复杂度也越大，那些既容易理解又容易编写的算法实在太少了。