首先是预处理,用动态规划(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])。
然后是查询。取k=[log2(j-i+1)],则有:RMQ(A, i, j)=min{F[i,k],F[j-2^k+1,k]}。 举例说明,要求区间[2,8]的最大值,总共2到8是7个元素,所以k=2,那么就要把它分成[2,5]和[5,8]两个区间,因为这两个区间的最大值我们可以直接由f[2,2]和f[5,2]得到。
具体如下图所示:
//初始化
INIT_RMQ
//max[i][j]中存的是重i开始的2^j个数据中的最大值,最小值类似,num中存有数组的值
for
i : 1 to n
max[i][0] = num[i]
for
j: 1 to
log
(n)/
log
(2)
for
i: 1 to (n+1-2^i)
max[i][j] = MAX(max[i][j-1], max[i+2^(i-1)][j-1])
//查询
RMQ(i, j)
k =
log
(j-i+1) /
log
(2)
return
MAX(max[i][k], max[
j-2^k+1 ][k])详解
Sparse Table算法,简称ST算法,可以用来求解RMQ(区间最值查询)问题。
RMQ问题的形式一般是:存在一个大数组,要求对于给定的起点和终点,迅速回答出这段区间的最大值或最小值。
朴素的方式是扫描起点到终点的所有数,维护其中的最值,这样的复杂度是O(n^2)的,速度太慢。ST算法是使用的是类似于二分的动态规划思想,其复杂度是O(nlogn),因此查询速度非常快。
ST算法的执行过程(以求最大值为例):
1、初始化:
设原数组为x[N]。
开辟一个数组dp[N][33]。其中dp[i][j]表示的是从下标为i的元素开始,到下标为(i + 2^j - 1)的元素为止,这些元素中的最大值。对于整型而言,其值不会超过2^32,因此第二维大小为33已经足够。
因此dp[i][0]表示的是元素本身,因此可以初始化为dp[i][0] = x[i]。
对于其他的dp[i][j],可以采用动态规划的方式求出,递推式为dp[i][j] = max(dp[i][j - 1], dp[i + 2 ^ (j - 1)][j - 1]),其实就是把一段区间切成两段大小相等的区间,当前区间的最大值就是两个子区间的最大值中的较大者。
初始化的复杂度为O(nlogn)。
2、求解:
对于给定的起点beg及终点end,可以得出区间大小为range = end - beg + 1。
因此可以找到一个整数k = (int)(log(range) / log2)。这样区间就可以被划分为子区间1,即[beg, beg + (2 ^ k) - 1],子区间2,即[end - (2 ^ k) + 1, end]。这两个可能会有重叠,但重叠不会影响最大值的求解。因此对于beg和end,可以得到解为res = max(dp[beg][k], dp[end - (2 ^ k) + 1][k])。
求解的复杂度为O(1)。
值得注意的是使用log求解k的速度比较慢,可以使用乘法来计算k,这样速度会相对快一些。
具体方法是:
k = 0, x = 2, range = end - beg + 1;
while (x <= range)
{
k++;
x <<= 1;
}
对于某个RMQ问题,总的复杂度为O(nlogn) + n * O(1) = O(nlogn),因此可以在足够快的时间内得到区间的最大值或最小值。
总结 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(qlogn)
3.ST(实质是动态规划) O(nlogn)-O(1)
线段树方法:
线段树能在对数时间内在数组区间上进行更新与查询。
定义线段树在区间[i, j] 上如下:
第一个节点维护着区间 [i, j] 的信息。
if i<j , 那么左孩子维护着区间[i, (i+j)/2] 的信息,右孩子维护着区间[(i+j)/2+1, j] 的信息。
可知 N 个元素的线段树的高度 为 [logN] + 1(只有根节点的树高度为0) .
下面是区间 [0, 9] 的一个线段树:![]()
线段树和堆有一样的结构, 因此如果一个节点编号为 x ,那么左孩子编号为2*x 右孩子编号为2*x+1.
使用线段树解决RMQ问题,关键维护一个数组M[num],num=2^(线段树高度+1).
M[i]:维护着被分配给该节点(编号:i 线段树根节点编号:1)的区间的最小值元素的下标。 该数组初始状态为-1.
- #include<iostream>
- using namespace std;
- #define MAXN 100
- #define MAXIND 256 //线段树节点个数
- //构建线段树,目的:得到M数组.
- void initialize(int node, int b, int e, int M[], int A[])
- {
- if (b == e)
- M[node] = b; //只有一个元素,只有一个下标
- else
- {
- //递归实现左孩子和右孩子
- initialize(2 * node, b, (b + e) / 2, M, A);
- initialize(2 * node + 1, (b + e) / 2 + 1, e, M, A);
- //search for the minimum value in the first and
- //second half of the interval
- if (A[M[2 * node]] <= A[M[2 * node + 1]])
- M[node] = M[2 * node];
- else
- M[node] = M[2 * node + 1];
- }
- }
- //找出区间 [i, j] 上的最小值的索引
- int query(int node, int b, int e, int M[], int A[], int i, int j)
- {
- int p1, p2;
- //查询区间和要求的区间没有交集
- if (i > e || j < b)
- return -1;
- //if the current interval is included in
- //the query interval return M[node]
- if (b >= i && e <= j)
- return M[node];
- //compute the minimum position in the
- //left and right part of the interval
- p1 = query(2 * node, b, (b + e) / 2, M, A, i, j);
- p2 = query(2 * node + 1, (b + e) / 2 + 1, e, M, A, i, j);
- //return the position where the overall
- //minimum is
- if (p1 == -1)
- return M[node] = p2;
- if (p2 == -1)
- return M[node] = p1;
- if (A[p1] <= A[p2])
- return M[node] = p1;
- return M[node] = p2;
- }
- int main()
- {
- int M[MAXIND]; //下标1起才有意义,保存下标编号节点对应区间最小值的下标.
- memset(M,-1,sizeof(M));
- int a[]={3,1,5,7,2,9,0,3,4,5};
- initialize(1, 0, sizeof(a)/sizeof(a[0])-1, M, a);
- cout<<query(1, 0, sizeof(a)/sizeof(a[0])-1, M, a, 0, 5)<<endl;
- return 0;
- }
ST算法(Sparse Table):它是一种动态规划的方法。
以最小值为例。a为所寻找的数组.
用一个二维数组f(i,j)记录区间[i,i+2^j-1](持续2^j个)区间中的最小值。其中f[i,0] = a[i];
所以,对于任意的一组(i,j),f(i,j) = min{f(i,j-1),f(i+2^(j-1),j-1)}来使用动态规划计算出来。
这个算法的高明之处不是在于这个动态规划的建立,而是它的查询:它的查询效率是O(1).
假设我们要求区间[m,n]中a的最小值,找到一个数k使得2^k<n-m+1.
这样,可以把这个区间分成两个部分:[m,m+2^k-1]和[n-2^k+1,n].我们发现,这两个区间是已经初始化好的.
前面的区间是f(m,k),后面的区间是f(n-2^k+1,k).
这样,只要看这两个区间的最小值,就可以知道整个区间的最小值!
- #include<iostream>
- #include<cmath>
- #include<algorithm>
- using namespace std;
- #define M 100010
- #define MAXN 500
- #define MAXM 500
- int dp[M][18];
- /*
- *一维RMQ ST算法
- *构造RMQ数组 makermq(int n,int b[]) O(nlog(n))的算法复杂度
- *dp[i][j] 表示从i到i+2^j -1中最小的一个值(从i开始持续2^j个数)
- *dp[i][j]=min{dp[i][j-1],dp[i+2^(j-1)][j-1]}
- *查询RMQ rmq(int s,int v)
- *将s-v 分成两个2^k的区间
- *即 k=(int)log2(s-v+1)
- *查询结果应该为 min(dp[s][k],dp[v-2^k+1][k])
- */
- void makermq(int n,int b[])
- {
- int i,j;
- for(i=0;i<n;i++)
- dp[i][0]=b[i];
- for(j=1;(1<<j)<=n;j++)
- for(i=0;i+(1<<j)-1<n;i++)
- dp[i][j]=min(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
- }
- int rmq(int s,int v)
- {
- int k=(int)(log((v-s+1)*1.0)/log(2.0));
- return min(dp[s][k],dp[v-(1<<k)+1][k]);
- }
- void makeRmqIndex(int n,int b[]) //返回最小值对应的下标
- {
- int i,j;
- for(i=0;i<n;i++)
- dp[i][0]=i;
- for(j=1;(1<<j)<=n;j++)
- for(i=0;i+(1<<j)-1<n;i++)
- dp[i][j]=b[dp[i][j-1]] < b[dp[i+(1<<(j-1))][j-1]]? dp[i][j-1]:dp[i+(1<<(j-1))][j-1];
- }
- int rmqIndex(int s,int v,int b[])
- {
- int k=(int)(log((v-s+1)*1.0)/log(2.0));
- return b[dp[s][k]]<b[dp[v-(1<<k)+1][k]]? dp[s][k]:dp[v-(1<<k)+1][k];
- }
- int main()
- {
- int a[]={3,4,5,7,8,9,0,3,4,5};
- //返回下标
- makeRmqIndex(sizeof(a)/sizeof(a[0]),a);
- cout<<rmqIndex(0,9,a)<<endl;
- cout<<rmqIndex(4,9,a)<<endl;
- //返回最小值
- makermq(sizeof(a)/sizeof(a[0]),a);
- cout<<rmq(0,9)<<endl;
- cout<<rmq(4,9)<<endl;
- return 0;
- }
应用:http://acm.pku.edu.cn/JudgeOnline/problem?id=3264
- #include<iostream>
- #include<stdio.h>
- #include<math.h>
- using namespace std;
- #define maxn 50001
- int a[maxn];
- int dpmax[maxn][40];
- int dpmin[maxn][40];
- int getmin(int a,int b)
- {
- if(a<b) return a;
- else return b;
- }
- int getmax(int a,int b)
- {
- if(a>b) return a;
- else return b;
- }
- void Make_Big_RMQ(int n)
- {
- int i,j;
- for(i=1;i<=n;i++) dpmax[i][0]=a[i];
- for(j=1;j<=log((double)n)/log(2.0);j++)
- for(i=1;i+(1<<j)-1<=n;i++)
- {
- dpmax[i][j]=getmax(dpmax[i][j-1],dpmax[i+(1<<(j-1))][j-1]);
- }
- }
- void Make_Min_RMQ(int n)
- {
- int i,j;
- for(i=1;i<=n;i++) dpmin[i][0]=a[i];
- for(j=1;j<=log((double)n)/log(2.0);j++)
- for(i=1;i+(1<<j)-1<=n;i++)
- {
- dpmin[i][j]=getmin(dpmin[i][j-1],dpmin[i+(1<<(j-1))][j-1]);
- }
- }
- int get_big_rmq(int a,int b)
- {
- int k=(int)(log((double)(b-a+1))/log(2.0));
- return getmax(dpmax[a][k],dpmax[b-(1<<k)+1][k]);
- }
- int get_min_rmq(int a,int b)
- {
- int k=(int)(log((double)(b-a+1))/log(2.0));
- return getmin(dpmin[a][k],dpmin[b-(1<<k)+1][k]);
- }
- int main()
- {
- int n,i,q,x,y;
- while(scanf("%d %d",&n,&q)!=EOF)
- {
- for(i=1;i<=n;i++)
- scanf("%d",&a[i]);
- Make_Big_RMQ(n);
- Make_Min_RMQ(n);
- for(i=1;i<=q;i++)
- {
- scanf("%d%d",&x,&y);
- printf("%d\n",get_big_rmq(x,y)-get_min_rmq(x,y));
- }
- }
- return 0;
- }