| Time Limit: 5000MS | Memory Limit: 65536K | |
| Total Submissions: 26435 | Accepted: 12401 | |
| Case Time Limit: 2000MS | ||
Description
For the daily milking, Farmer John's N cows (1 ≤ N ≤ 50,000) always line up in the same order. One day Farmer John decides to organize a game of Ultimate Frisbee with some of the cows. To keep things simple, he will take a contiguous range of cows from the milking lineup to play the game. However, for all the cows to have fun they should not differ too much in height.
Farmer John has made a list of Q (1 ≤ Q ≤ 200,000) potential groups of cows and their heights (1 ≤height ≤ 1,000,000). For each group, he wants your help to determine the difference in height between the shortest and the tallest cow in the group.
Input
Lines 2..N+1: Line i+1 contains a single integer that is the height of cow i
Lines N+2..N+Q+1: Two integers A and B (1 ≤ A ≤ B ≤ N), representing the range of cows from A toB inclusive.
Output
Sample Input
6 3 1 7 3 4 2 5 1 5 4 6 2 2
Sample Output
6 3 0
Source
RMQ分析
（PS：思路同上书所述）
RMQ(Range Minimum/Maximum Query)问题：
RMQ问题是求给定区间中的最值问题。当然，最简单的算法是O(n)的，但是对于查询次数很多（设置多大100万次），O(n)的算法效率不够。可以用线段树将算法优化到O（logn)（在线段树中保存线段的最值）。不过，Sparse_Table算法才是最好的：它可以在O(nlogn)的预处理以后实现O(1)的查询效率。下面把Sparse Table算法分成预处理和查询两部分来说明(以求最小值例)。
预处理:(以求区间最小值为例) O (nlogn)
预处理使用DP的思想，f(i, j)表示[i, i+2^j - 1]区间中的最小值（也就是表示从 i 开始的，长度为 2^j 的一段元素中的最小值，）。
我们可以开辟一个数组专门来保存f(i, j)的值。
例如，f(0, 0)表示[0,0]之间的最小值,就是num[0], f(0, 2)表示[0, 3]之间的最小值, f(2, 4)表示[2, 17]之间的最小值
注意： 因为f(i, j)可以由f(i, j - 1)和f(i+2^(j-1), j-1)导出, 而递推的初值(所有的f(i, 0) = i)都是已知的
所以我们可以采用自底向上的算法递推地给出所有符合条件的f(i, j)的值。
递推方程：f(i, j) = min { f(i, j-1), f(i+2^(j-1), j-1) }
注意： 2^j <=n 因此数组的元素个数不超过 nlogn,而没一项都可以在常数时间计算完毕，故总时间为O（nlogn）
预处理代码如下：
//元素从 1 编到 n
void RMQ_init()
{
for(int i = 1; i <= n; i++)
{
d_min[i][0] = a[i]; // 2^0 = 1
}
for(int j = 1; (1<<j) <= n; j++) // 2^j <= n
{
for(int i = 1; i+(1<<j)-1 <= n; i++) // i+2^j-1 <= n
{
d_min[i][j] = min(d_min[i][j-1], d_min[i+(1<<(j-1))][j-1]);
}
}
}
查询:O(1)
假设要查询从R到L这一段的最小值, 首先令 k 为满足 2^k <= R-L+1 的最大整数，则以 L 开头、以 R 结尾的两个长度为 2^k 的区间合起来即覆盖了查询区间 [L, R]。
两个重叠的区间区间 f(L, k) 也就是【L, L+2^k-1】 ，f(R-2^k+1, k) 也就是【R-2^k+1, R】。
由于是取最小值，有些元素重复考虑了几遍也没有关系（注意：如果是累加，重复元素是不许的）。
我们之前已经求出了f(L, k)为[L, L+2^k-1]的最小值, f(R-2^k+1, k)为[R-2^k+1, R]的最小值
我们只要返回其中更小的那个, 就是我们想要的答案, 这个算法的时间复杂度是O(1)的.
例如, RMQ(0, 11) = min(f(0, 3), f(4, 3))
由此我们要注意的是预处理f(i,j)中的j值只需要计算log(n+1)/log(2)即可，而i值我们也只需要计算到n-2^k+1即可。
查询代码如下：
int RMQ_Min(int L, int R)
{
int k = 0;
while((1<<(k+1)) <= R-L+1) k++; // 如果 2^(k+1) <= R-L+1,那么k 还可以加 1
return min(d_min[L][k], d_min[R-(1<<k)+1][k]);
}PS：好像还有个效率为O(n)的，暂时无法理解ing...就先用这个了。
/*
*3264
*Accepted
*8168K
*1719MS
*C++
*1162B
*O(n*logn)
*/
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
const int maxn = 50000+10;
int d_max[maxn][20];
int d_min[maxn][20];
int a[maxn];
int n,q;
void RMQ_init()
{
for(int i = 1; i <= n; i++)
{
d_min[i][0] = a[i]; // 2^0 = 1
d_max[i][0] = a[i];
}
for(int j = 1; (1<<j) <= n; j++) // 2^j <= n
{
for(int i = 1; i+(1<<j)-1 <= n; i++) // i+2^j-1 <= n
{
d_min[i][j] = min(d_min[i][j-1], d_min[i+(1<<(j-1))][j-1]);
d_max[i][j] = max(d_max[i][j-1], d_max[i+(1<<(j-1))][j-1]);
}
}
}
int RMQ_Min(int L, int R)
{
int k = 0;
while((1<<(k+1)) <= R-L+1) k++; // 如果 2^(k+1) <= R-L+1,那么k 还可以加 1
return min(d_min[L][k], d_min[R-(1<<k)+1][k]);
}
int RMQ_Max(int L, int R)
{
int k = 0;
while((1<<(k+1)) <= R-L+1) k++; // 如果 2^(k+1) <= R-L+1,那么k 还可以加 1
return max(d_max[L][k], d_max[R-(1<<k)+1][k]);
}
int main()
{
while(scanf("%d%d", &n, &q) != EOF)
{
for(int i = 1; i <= n; i++)
{
scanf("%d", &a[i]);
}
RMQ_init();
int a,b;
while(q--)
{
scanf("%d%d", &a, &b);
printf("%d\n", RMQ_Max(a, b) - RMQ_Min(a, b));
}
}
return 0;
}刚刚问了下 ORC 他说他用线段树做的，感觉效率还是比我上面的这个高，就要了代码和思路，贴一下。
/*
*我的代码是先建树，然后再查找
*建树的时候把每个区间的最大值和最小值找出来
*查找的时候已找到那个区间就知道最大值和最小值了
*/
/*
*Accepted
*2388 KB
*1766 ms
*C++
*1690 B
*/
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
#define N 50001
int v[N],Max,Min;
struct node{
int left,right;
int max,min;
int mid()
{ return (left+right)/2;}
}T[N*3];
void build(int root,int l,int r) //建树
{
T[root].left = l;
T[root].right = r;
//printf("%d %d",T[root].left,T[root].right); //建树的时候可以“单步调试”，看它是怎么建的
if(l == r)//如果没有孩子了，说明孩子树已经建完了
{
T[root].max = T[root].min = v[l];
return ;
}
else
{
int mid = T[root].mid();
build(root<<1, l,mid);//建树的顺序是从左到右,root<<1相当于root*2
build(root<<1|1, mid+1,r);//root<<1|1相当于root*2+1
T[root].max = max(T[root*2].max, T[root*2+1].max);
T[root].min = min(T[root*2].min, T[root*2+1].min);
}
}
void query(int root,int l,int r)//查找线段
{
// printf("%d %d",T[root].left,T[root].right); //查找的时候可以“单步调试”，看它是怎么查找的
if(T[root].left==l && T[root].right==r)
{
Max=max(T[root].max, Max);
Min=min(T[root].min, Min);
return ;
}
else
{
int mid=T[root].mid();
if(r <= mid)//在左孩子找
{
query(root<<1, l, r);
}
else if(l > mid)//在右孩子找
{
query(root<<1|1, l, r);
}
else //拆两半
{
query(root<<1, l, mid);
query(root<<1|1, mid+1, r);
}
}
}
int main()
{
int i,j,n,m;
scanf("%d%d", &n, &m);
for(i = 1; i <= n; i++)
scanf("%d",&v[i]);
build(1, 1, n);
for(i = 1;i <= m; i++)
{
int st, en;
scanf("%d%d", &st, &en);
Max=-1000111222;
Min=1000111222;
query(1,st,en);
printf("%d\n",Max-Min);
}
return 0;
}