RMQ问题的树状数组解法

树状数组中每个元素覆盖了不同长度的子区间，类似于稀疏表(ST)算法的思想，每一个数组元素存储了输入数列A在该区间的最小值下标。注意：这里树状数组不是用来存储区间累加值，而是区间的最小值下标。

这里针对预处理阶段提供两个算法：方法1(参考以下实现代码中的方法preprocess)采用类似于累加和中的update做法，每一个元素A[i]需要处理树状数组T中O(logn)个受影响的元素，因此预处理复杂度为O(nlogn)。方法2(参考以下实现代码中的方法preprocess2或preprocess3)利用DP（动态规划）思想，观察到树状数组中每一个下标为i的元素覆盖的区间都可以划分为：r个子区间 + 最后一个元素A[i]。（其中2^r=lowbit(i)）因此只需要计算这r+1个区间中的最小值即可，该算法的复杂度为可以这样计算：对树中每一层所有元素基本操作做累加，例如叶子结点个数为n/(2^1)，每一个叶子结点基本操作次数为1，倒数第二层的结点个数为n/(2^2)，其中每一个结点的基本操作次数为2....所以总的基本操作次数为1
* n/(2^1) + 2 * n/(2^2) + 3 * n/(2^3) + ...+ k * n/(2^k) + ... + logn * n/(2^logn) = O(n)。可见第二个方法比第一个方法复杂度要小。在以下的实现代码中，方法preprocess2或preprocess3是等效的，preprocess3使用了类似累加和中的query做法，即找出互不重叠的子区间。

查询时，采用递归做法，分两种情形: case 1) 如果查询的区间在当前区间中，则将当前区间最后一个元素剥离开来，使查询区间长度减1；case 2)如果查询的区间与当前区间没有重叠，则将当前区间所有元素剥离开来，使查询区间长度减去lowbit值（即2^r）。最糟情况下需要执行case 1）总共logn次，每次查询时树高度减1，所以查询的复杂度为(logn-1) + (logn-2)+...+1=O(logn*logn)。

跟ST算法或线段树算法相比，树状数组解RMQ问题的优势是存储空间小。预处理复杂度跟线段树算法相当（采用上面的方法2），但是查询的复杂度比线段树算法中的O(logn)要大。通过时间换空间达到时空平衡，再加上编程简单，树状数组算法还是有一定价值的。

注意：在下面的代码中数组A的下标永远都是从0开始，而树状数组T的有效下标从1开始（T[0]没有被利用）。另外，查询部分是tail recursion，实际上可以改写为迭代计算。

实现：

/**
*
* RMQ algorithm using Binary Indexed Tree (BIT)
*
* Copyright (c) 2011 ljs (http://blog.csdn.net/ljsspace/)
* Licensed under GPL (http://www.opensource.org/licenses/gpl-license.php)
*
*
* @author ljs
* 2011-08-10
*
*/
public class RMQ_BIT {
//each element is a min-val index in the range i-2^r +1 ...  i
private int[] T;

public RMQ_BIT(int n) {
//each element in T is initialized to 0
T = new int[n + 1];
//init T
for(int i=1;i<=n;i++){
T[i] = -1;
}
}
//preprocess method 1: create BIT - O(nlogn)
public void preprocess(int[] A){
int n = A.length;
for(int i=0;i<n;i++){
update(A,i);
}
}
//A better preprocess method 2: create BIT - O(n)
public void preprocess2(int[] A){
int n = A.length;
for(int i=1;i<=n;i++){
int k = lowbit(i);
T[i] = i-1; //initial value
//each subrange's index is left shifted by 1 (=divide by 2)
for(int j=1;j<k;j<<=1){
//Note: use == for canonical RMQ result
if(A[T[i]]>=A[T[i-j]]){
T[i] = T[i-j];
}
}
}
}

//another form of preprocess2: similar to query in BIT
public void preprocess3(int[] A){
int n = A.length;
for(int i=1;i<=n;i++){
int j = i - lowbit(i);
T[i] =  i - 1; //set the initial value of T[i]: i-1 is an index of A
int k = i - 1; //i-1 is the next index of T
while(k>j){
//Note: use == for canonical RMQ result
if(A[T[i]]>=A[T[k]]){
T[i] = T[k];
}
k -= lowbit(k);
}
}
}

private int lowbit(int x){
return x & (-x);
}
//idx is A's index, starting with 0
private void update(int[] A,int idx) {
int x = idx+1; //A's index starts with 0
int val = A[idx];
while (x < T.length) {
if(T[x] ==-1 || A[T[x]] > val){
T[x] = idx;
}
x += lowbit(x);
}
}
//i,j are A's index, starting with 0
public int query(int[] A,int i,int j){
if(i>j){
//swap
int tmp=i;i=j;j=tmp;
}
return query(A,i+1,j+1,j);
}
//precondition: p...q must be in the range: 1...n (inclusive)
private int query(int[] A,int p,int q,int minIndex){
if(p>q) return minIndex;

int j = q - lowbit(q);
if(p>j){
//p..q is equal to or less than T[q]'s coverage
if(A[q-1] <= A[minIndex])minIndex = q-1;
return query(A,p,q-1,minIndex);
}else{ // if(p<=j)
//p..q is greater than T[q]'s coverage
if(A[T[q]] <= A[minIndex])minIndex = T[q];
return query(A,p,j,minIndex);
}
}

private void reportLUTable(int[] A){
System.out.format("%n***********************%n");
for(int x=0;x<A.length;x++){
System.out.format("%d..[%d-%d]",x,x,A.length-1);
for(int y=x;y<A.length;y++){
int p = query(A,x,y);
System.out.format(" %d/%d",A[p],p);
}
System.out.println();
}
}

public static void main(String[] args) {
int[] A = new int[]{2,4,3,1,6,7,8,9,1,7};
int n = A.length;
RMQ_BIT bitRMQ = new RMQ_BIT(n);

bitRMQ.preprocess3(A);
int i=0;
int j=3;
int min = bitRMQ.query(A, i,j);
System.out.format("RMQ for A[%d..%d]: A[%d]=%d", i,j,min,A[min]);

bitRMQ.reportLUTable(A);

////////////////////
System.out.format("%n***********************%n");

A=new int[]{10,15,34,20,7,5,18,68,29,40, //0..9
24,3,45,26,7,23,43,12,68,34,  //10..19
26,34,33,12,80,57,24,42,77,27, //20..29
56,33,23,32,54,13,79,65,19,33,  //30..39
15,24,43,73,55,13,63,8,23,17};  //40..49
n = A.length;
bitRMQ = new RMQ_BIT(n);

bitRMQ.preprocess3(A);

i=0;
j=10;
min = bitRMQ.query(A,i,j);
System.out.format("RMQ for A[%d..%d]: A[%d]=%d%n", i,j,min,A[min]);

i=12;
j=49;
min = bitRMQ.query(A,i,j);
System.out.format("RMQ for A[%d..%d]: A[%d]=%d%n", i,j,min,A[min]);

i=20;
j=46;
min = bitRMQ.query(A,i,j);
System.out.format("RMQ for A[%d..%d]: A[%d]=%d%n", i,j,min,A[min]);

i=20;
j=49;
min = bitRMQ.query(A,i,j);
System.out.format("RMQ for A[%d..%d]: A[%d]=%d%n", i,j,min,A[min]);

}

}

测试输出：

RMQ for A[0..3]: A[3]=1

***********************

0..[0-9] 2/0 2/0 2/0 1/3 1/3 1/3 1/3 1/3 1/3 1/3

1..[1-9] 4/1 3/2 1/3 1/3 1/3 1/3 1/3 1/3 1/3

2..[2-9] 3/2 1/3 1/3 1/3 1/3 1/3 1/3 1/3

3..[3-9] 1/3 1/3 1/3 1/3 1/3 1/3 1/3

4..[4-9] 6/4 6/4 6/4 6/4 1/8 1/8

5..[5-9] 7/5 7/5 7/5 1/8 1/8

6..[6-9] 8/6 8/6 1/8 1/8

7..[7-9] 9/7 1/8 1/8

8..[8-9] 1/8 1/8

9..[9-9] 7/9

***********************

RMQ for A[0..10]: A[5]=5

RMQ for A[12..49]: A[14]=7

RMQ for A[20..46]: A[23]=12

RMQ for A[20..49]: A[47]=8