POJ 3264 RMQ问题 ST算法

因为之前都是线段树解决RMQ问题，省脑子……（因为写的顺手）……

但是因为RMQ毕竟常数大，而且其实程序还相对ST要长…… 以前写过ST算法，但是因为每次都在纠结到底+1 呢，还是-1呢， 边界问题处理的我蛋都碎了好几次，这次重新学习了一下ST(sparse table)算法，好好的处理了这些问题的理解。

ST算法：  解决RMQ问题。 RMQ问题：

区间最大值，最小值问题……

时间复杂度： 预处理nlogn, 查询O(1)。 预处理和查询的常数都极小。线段树虽然是nlogn预处理，但是常数略大，而且查询是logn的…… 当然了，线段树还有其他支持的操作，暂且不谈。

ST算法局限性：解决静态RMQ问题。 但是！ RMQ和后缀数组联手，就非常好用了！

正题：

（这个字有点太小了？赶紧换大号字）

这么大的字看起来舒服多了，对于我这近视眼而言。。

这样的字靠谱点……就这样好了。

st[i][j] 表示，，  r[i] r[i + 1] r[i + 2] .... r[i + 2^j - 1] 这一连串，数组下标从 i到i + 2^j -1的区间内，最值是多少。（从这里开始，最值就当最小值了，最大值同理。）

那么显然，st[i][0] = r[i];   因为  r[i] .. r[i + 1] ... r[i + 2^0 - 1] 实质上就是 r[i]到r[i]这个区间……也就是说，初始化st[i][0] = r[i]即可。

下面重点来了， st[i][j] = min( s[i][j - 1] ,  s[i + 2^(j-1)][j-1]是怎么来的呢？

我们举个例子。

当i = 3, j = 3的时候， st[3][3]所表示的区间就是         3 4 5 6 [7 8 9 10]

    i = 3, j = 2的时候， st[3][2] 所表示的区间显然是    3 4 5 6

    这个时候我们就可以明显看出来了，我们需要从7的位置开始 也就是需要st[7][2] 所表示的区间 7 8 9 10

那么st[3][3] = min(st[3][2] , st[7][2]);

这样的话，构造过程就出来了。

下面的程序就表示，如何构造出最大和最小的两个情况。

void makermq(int *r, int n)
{
	for (int i = 0; i != n; ++ i)	stmax[i][0] = stmin[i][0] = r[i];
	for (int i = 1; (1 << i) <= n; ++ i)
		for (int j = 0; j + (1 << i) - 1 < n; ++ j)
		{
			stmax[j][i] = max(stmax[j][i - 1], stmax[j + (1 << (i - 1))][i - 1]);
			stmin[j][i] = min(stmin[j][i - 1], stmin[j + (1 << (i - 1))][i - 1]);
		}
}

i =1开始穷举2^i ，

st[0][i] 为  [0] [1] [2] [3] ... [2^i -1] 的区间。  如果出现了[2^i -1]所表示的下标，已经达到，甚至超过n的话，显然就不需要再计算了，

2^i - 1 也就是 (1 << i ) - 1, 他的值必须要比n要小（0为下标起点）。

第二层循环

j 作为穷举的区间起点位置（终点位置是j + 2^i -1）， 那么他的终点位置也必须在n以为。 所以就是

j + (1 << i) - 1 < n

至于判断取值的情况……

[j, j + 2^i - 1]整个区间，拆成2个一样长的区间。

 [  j，  j + 2^(i - 1) - 1， ] 区间，  和[ j + 2^(i - 1), j + 2^i - 1] 两个区间，后者实质就是st[j + 2^(i - 1)][i - 1];

整个区间最小值，也就是

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

这样就解决了初始化的问题。 时间复杂度nlogn

===============

接下来是如何实现O(1)的查询。

假如要查询 3 4 5 6 7 8这个区间的最小值，实际上，我们给他分成两份

查询 3 4 5 6 和5 6 7 8 的最小值，两者取最小就行了。  因为只要有交集，并且并集能覆盖整个区间，那么他的最小值一定就是他们整个区间的最小值。

下面就是思考如何知道就是从st[3][2]和st[5][2]这2个地方查询呢？

不管怎么样，L + 2^i - 1  (这也就是st[L][i]所表示区间的最右边) 必须要比R小或者相等……  区间：L,   L + 2 ^i - 1

R - 2^i + 1又一定要比L要大或者相等    区间 ：   R - 2^I + 1, R

同时，他们还要有并集！也就是R - 2 ^i + 1 >=  L + 2 ^i  - 1

综上：要找出一个最小的i，满足

   L + 2 ^i  - 1 >= R - 2 ^i + 1

化简后i = log(R - L + 2) / log(2) - 1 的结果向上取整（如果本身是整数，则不动）

这个式子用C语言表示很复杂- -我直接省事用dd

i = int(log(r - l + 2)/log(2) + 0.99999) - 1; 表示， 是可以通过测试的……

当然，这个表示方法并不科学，我们没有利用好很多条件。

还看这个式子：

R - 2 ^i + 1 >=  L + 2 ^i  - 1

还可以写成  L + 2^i - 1 > R - 2^i + 1

化简得 i + 1 >  （log(R-L+1) /log(2)）

小于号右边的式子，是一个整数，  

根据一个结论： 一个带小数点的数字，取整+1，一定大于这个数字本身。  

这么看来，i作为右边那个带小数点的数字即可。  i = (int) （log(R-L+1) /log(2)）

当然， i = (int) （log(R-L+1) /log(2)）的写法，还可以通过其他方式解释，比如区间长度，但是我感觉思维量略大，我不想多想了

这样一来，程序就出来了。 flag表示询问是大还是小

 

int ask(int l, int r, int flag)
{
	//int tmp = int(log(r - l + 2)/log(2) + 0.99999) - 1; //不科学方法，也能通过测试
	int tmp = int(log(r - l + 1)/log(2));
	if (!flag)	return min(stmin[l][tmp], stmin[r - (1 << tmp) + 1][tmp]);
	else return max(stmax[l][tmp], stmax[r - (1 << tmp) + 1][tmp]);
}

全部程序如下：

#include <cstdio>
#include <cstdio>
#include <iostream>
#include <cmath>
using namespace std;

const int max_n = 50000 + 10;
int n, questions;
int stmax[max_n][20], stmin[max_n][20];
int a[max_n];
void makermq(int *r, int n)
{
	for (int i = 0; i != n; ++ i)	stmax[i][0] = stmin[i][0] = r[i];
	for (int i = 1; (1 << i) <= n; ++ i)
		for (int j = 0; j + (1 << i) - 1 < n; ++ j)
		{
			stmax[j][i] = max(stmax[j][i - 1], stmax[j + (1 << (i - 1))][i - 1]);
			stmin[j][i] = min(stmin[j][i - 1], stmin[j + (1 << (i - 1))][i - 1]);
		}
}

int ask(int l, int r, int flag)
{
	//int tmp = int(log(r - l + 2)/log(2) + 0.99999) - 1; //不科学方法，也能通过测试
	int tmp = int(log(r - l + 1)/log(2));
	if (!flag)	return min(stmin[l][tmp], stmin[r - (1 << tmp) + 1][tmp]);
	else return max(stmax[l][tmp], stmax[r - (1 << tmp) + 1][tmp]);
}


int main()
{
	scanf("%d%d", &n, &questions);
	for (int i = 0; i != n; ++ i)	scanf("%d", &a[i]);
	makermq(a, n);
	while (questions -- )
	{
		int L ,R;
		scanf("%d%d", &L, &R);
		--L, --R;
		int a = ask(L, R, 1);
		int b = ask(L, R, 0);	
		printf("%d\n", a - b);
	}
	return 0;
}