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