概述：
RMQ（Range Minimum/Maximum Query），即区间最值查询，是指这样一个问题：对于长度为n的数列A，回答若干询问RMQ（A,i,j）(i,j<=n)，返回数列A中下标在i，j之间的最小/大值。这两个问题是在实际应用中经常遇到的问题，下面介绍一下解决这两种问题的比较高效的算法。当然，该问题也可以用线段树（也叫区间树）解决，算法复杂度为：O(N)~O(logN)，这里我们暂不详细介绍，有空填坑。
线段树是一种二叉搜索树，与区间树相似，它将一个区间划 分成一些单元区间，每个单元区间对应线段树中的一个叶结 点。 使用线段树可以快速的查找某一个节点在若干条线段中出现 的次数，时间复杂度为O(logN)。而未优化的空间复杂度为 2N，因此有时需要离散化让空间压缩
对于该问题，最容易想到的解决方案是遍历，复杂度是O(n)。但当数据量非常大且查询很频繁时，该算法无法在有效的时间内查询出正解。
本节介绍了一种比较高效的在线算法（ ST算法（ 稀疏表(Sparse Table ) ））解决这个问题。所谓在线算法，是指用户每输入一个查询便马上处理一个查询。该算法一般用较长的时间做预处理，待信息充足以后便可以用较少的时间回答每个查询。ST（Sparse Table）算法是一个非常有名的在线处理RMQ问题的算法，它可以在O(nlogn)时间内进行预处理，然后在O(1)时间内回答每个查询。
（一）首先是预处理，用动态规划（DP）解决。
设A[i]是要求区间最值的数列，F[i, j]表示从第i个数起连续2^j个数中的最大值。（DP的状态）
例如：
A数列为：3 2 4 5 6 8 1 2 9 7
F[1，0]表示第1个数起，长度为2^0=1的最大值，其实就是3这个数。同理 F[1,1] = max(3,2) = 3, F[1，2]=max(3,2,4,5) = 5，F[1，3] = max(3,2,4,5,6,8,1,2) = 8;
并且我们可以容易的看出F[i,0]就等于A[i]。（DP的初始值）
这样，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]）。
代码如下：
1 void RMQ(int num) //预处理->O(nlogn) 2 { 3 for(int j = 1; j < 20; ++j) 4 for(int i = 1; i <= num; ++i) 5 if(i + (1 << j) - 1 <= num) 6 { 7 maxsum[i][j] = max(maxsum[i][j - 1], maxsum[i + (1 << (j - 1))][j - 1]); 8 minsum[i][j] = min(minsum[i][j - 1], minsum[i + (1 << (j - 1))][j - 1]); 9 } 10 }
这里我们需要注意的是循环的顺序，我们发现外层是j，内层是i，这是为什么呢？可以是i在外，j在内吗？
答案是不可以。因为我们需要理解这个状态转移方程的意义。
状态转移方程的含义是：先更新所有长度为F[i,0]即1个元素，然后通过2个1个元素的最值，获得所有长度为F[i,1]即2个元素的最值，然后再通过2个2个元素的最值，获得所有长度为F[i,2]即4个元素的最值，以此类推更新所有长度的最值。
而如果是i在外，j在内的话，我们更新的顺序就是F[1,0],F[1,1],F[1,2],F[1,3],表示更新从1开始1个元素，2个元素，4个元素，8个元素（A[0],A[1],....A[7]）的最值，这里F[1,3] = max(max(A[0],A[1],A[2],A[3]),max(A[4],A[5],A[6],A[7]))的值，但是我们根本没有计算max(A[0],A[1],A[2],A[3])和max(A[4],A[5],A[6],A[7])，所以这样的方法肯定是错误的。
为了避免这样的错误，一定要好好理解这个状态转移方程所代表的含义。
（二）然后是查询。
假如我们需要查询的区间为(i,j)，那么我们需要找到覆盖这个闭区间(左边界取i，右边界取j)的最小幂（可以重复，比如查询5，6，7，8，9，我们可以查询5 6 7 8和6 7 8 9）。
因为这个区间的长度为j - i + 1,所以我们询问时只要取k=log2( j - i + 1)即k=ln(j-i+1)/ln2即可，
那么可以令A为i到2^k的块，和B为到2^k结束的长度为2^k的块;那么A，B都是区间[i,j]的子区间，所以即求A区间的最小值和B区间的最大/小值的最大/小值。
则有：RMQ(A, i, j)=max{F[i , k], F[ j - 2 ^ k + 1, k]}。
举例说明，要求区间[2，8]的最大值，k = log2（8 - 2 + 1）= 2，即求max(F[2, 2]，F[8 - 2 ^ 2 + 1, 2]) = max(F[2, 2]，F[5, 2])；
在这里我们也需要注意一个地方，就是<<运算符和+-运算符的优先级。
比如这个表达式：5 - 1 << 2是多少？
答案是：4 * 2 * 2 = 16。所以我们要写成5 - (1 << 2)才是5-1 * 2 * 2 = 1。
此文章仅供自己回顾知识点，转载自：https://blog.csdn.net/niushuai666/article/details/6624672/，并根据自己需要稍加了改动。
线段树实现RMQ
主要思路
线段树是维护区间的一类高效数据结构,依据这个特性,我们可以用线段树实现RMQ算法,用线段树实现的RMQ算法不仅可以查询区间最小值,还可以更改某个节点的值
代码实现
1 #include<bits/stdc++.h> 2 using namespace std; 3 typedef long long int LL; 4 const int MAXN=18; 5 const int INF=1e9; 6 int num[2*(1<<MAXN)]; 7 int n; 8 void init(int base){ 9 n=1; 10 while(n<base){ 11 n<<=1; 12 } 13 for(int i=0;i<2*n-1;i++){ 14 num[i]=INF; 15 } 16 } 17 void change_k(int k,int a){//将节点k的值赋为a 18 k+=n-1; 19 num[k]=a; 20 while(k){ 21 k=(k-1)>>1; 22 num[k]=min(num[2*k+1],num[2*k+2]); 23 } 24 } 25 int get_min(int a,int b,int k,int l,int r){ 26 if(a<=l&&b>=r) return num[k]; 27 else if(a>=r||b<=l) return INF; 28 else { 29 // cout<<l<<" "<<r<<endl; 30 // 递归至左右子树求解 31 int lc=get_min(a,b,2*k+1,l,(l+r)/2); 32 int rc=get_min(a,b,2*k+2,(l+r)/2,r); 33 return min(lc,rc); 34 } 35 } 36 int main(){ 37 scanf("%d",&n); 38 int cnt=n; 39 init(n); 40 for(int i=0;i<cnt;i++){ 41 int tmp; 42 scanf("%d",&tmp); 43 change_k(i,tmp); 44 } 45 int a,b; 46 scanf("%d %d",&a,&b); 47 /* 48 int k,num; 49 scanf("%d %d",&k,&num); 50 change_k(k,num); 51 这里还可以实现更改 52 */ 53 printf("%d ",get_min(a,b,0,0,n)==INF?-1:get_min(a,b,0,0,n)); 54 }
时间复杂度
预处理时,操作的节点个数为n+n/2+n/4+……,约为2n个,所以复杂度为O(n),每一次查询与修改区间值的复杂度是O(log n).
3.例题剖析：
以后再填坑
当然对于RMQ并不只有这个用法，我们可以用它来解决LCA问题。
假设LCA(T,u,v)表示在有根树T中，询问一个离根最远的结点x,使得x为u,v的公共祖先。现在分析下LCA向RMQ问题转化的过程:
对有根树T进行深度优先遍历(DFS),将遍历到的结点按照顺序记录下来，那么我们会得到一个长度为2N-1的序列，称之为T的欧拉序列F，设序列Depth是DFS遍历过程中的结点深度的变化情况。其中每一个结点都会出现在欧拉序列F中，我们记录结点u在欧拉序列中出现的第一个位置pos(u);根据DFS的特性，对于任意两个结点u,v，那么从pos(u)(也就是第一次访问u的时候)到pos(v)(第一次访问v)的过程中，所经历的路径为F(pos(u).....pos(v)),虽然这些包括u的后代，但是其深度最小的结点一定是u和v的LCA(公共祖先)，不论pos(u)与pos(v)的关系如何，都一定有LCA(T,u,v)=RMQ(Depth,pos(u),pos(v));
下面这个图是有根树的欧拉序列F和深度序列B已经pos(u)的变化情况:
1 深度为0
/
2 3 4 深度为1
/
5 6 深度为2
那么欧拉序列F:1 2 5 2 6 2 1 3 1 4 1；深度序列Depth为: 0 1 2 1 2 1 0 1 0 1 0，pos(u)为:1 2 8 10 3 5
还是以poj 1330为例：将LCA转化为RMQ求解，
1 #include<iostream> 2 #include<cstring> 3 #include<cstdio> 4 #include<cmath> 5 #include<vector> 6 using namespace std; 7 const int MAX=20001;//定义10001RE了n次,定义太小了,以后RE后可以适当的把数组开大点 8 #define CLR(arr,val) memset(arr,val,sizeof(arr)) 9 int n,total,Depth[2*MAX],pos[MAX],F[2*MAX],Indegree[MAX]; 10 vector<int> Adj[MAX]; 11 bool visited[MAX]; 12 void Init() 13 { total=0; 14 CLR(pos,0); 15 CLR(Indegree,0); 16 CLR(visited,false); 17 for(int i=0;i<MAX;i++) Adj[i].clear(); 18 } 19 void DFS(int u,int cur)//cur记录深度 20 { if(!visited[u])//说明该节点未被访问过,那么记录第一次出现的位置 21 { visited[u]=true; 22 pos[u]=total; 23 } 24 Depth[total]=cur;//记录深度序列 25 F[total++]=u;//记录欧拉序列 26 for(vector<int>::size_type i=0;i<Adj[u].size();i++) 27 { DFS(Adj[u][i],cur+1); 28 Depth[total]=cur; 29 F[total++]=u; 30 } 31 } 32 class RMQ{ 33 public: 34 void clear(){CLR(DP,0);} 35 void rmq() 36 { int temp=(int)(log((double)total)/log(2.0)); 37 for(int i=0;i<total;i++) 38 DP[i][0]=i; 39 for(int j=1;j<=temp;++j) 40 for(int i=0;i<total;++i) 41 DP[i][j]=Depth[DP[i][j-1]]<Depth[DP[i+(1<<(j-1))][j-1]]?DP[i][j-1]:DP[i+(1<<(j-1))][j-1]; 42 } 43 int Minimum(int L,int H) 44 { int k=(int)(log((double)H-L+1)/log(2.0)); 45 return Depth[DP[L][k]]<Depth[DP[H-(1<<k)+1][k]]?DP[L][k]:DP[H-(1<<k)+1][k]; 46 } 47 private: 48 int DP[2*MAX][20]; 49 }R; 50 int LCA(int u,int v) 51 { return u<=v?R.Minimum(u,v):R.Minimum(v,u); 52 } 53 int main() 54 { int k,u,v; 55 scanf("%d",&k); 56 while(k--) 57 { scanf("%d",&n); 58 R.clear(); 59 Init(); 60 for(int i=0;i<n-1;i++) 61 { scanf("%d%d",&u,&v); 62 Adj[u].push_back(v); 63 Indegree[v]++; 64 } 65 for(int i=1;i<=n;i++)//从根结点开始DFS 66 if(!Indegree[i]) {DFS(i,0);break;} 67 R.rmq(); 68 scanf("%d%d",&u,&v); 69 printf("%d ",F[LCA(pos[u],pos[v])]); 70 } 71 return 0; 72 }
原文：https://blog.csdn.net/xuzengqiang/article/details/7350465
Balanced Lineup
题意：给出n个数，m个操作，每次操作求x-y区间内的最大差值
模板题，线段树也能做，现在用ST来做
1 #include <cstdio> 2 #include <stack> 3 #include <iostream> 4 #include <algorithm> 5 #include <cstring> 6 #include <math.h> 7 using namespace std; 8 9 int dpmax[50010][20]; 10 int dpmin[50010][20]; 11 12 void Query(int l,int r) 13 { 14 int k=log(r-l+1.0)/log(2.0); 15 int big=max(dpmax[l][k],dpmax[r-(1<<k)+1][k]); 16 int small=min(dpmin[l][k],dpmin[r-(1<<k)+1][k]); 17 // printf("big=%d small=%d ",big,small); 18 printf("%d ",big-small); 19 } 20 21 int main() 22 { 23 //freopen("sample.txt","r",stdin); 24 int n,q; 25 scanf("%d %d",&n,&q); 26 for(int i=1;i<=n;i++) 27 { 28 int t; 29 scanf("%d",&t); 30 dpmax[i][0]=t; 31 dpmin[i][0]=t; 32 } 33 for(int j=1;(1<<j)<=n;j++) 34 { 35 for(int i=1;i+(1<<j)-1<=n;i++) 36 { 37 dpmax[i][j]=max(dpmax[i][j-1],dpmax[i+(1<<(j-1))][j-1]); 38 dpmin[i][j]=min(dpmin[i][j-1],dpmin[i+(1<<(j-1))][j-1]); 39 } 40 } 41 while(q--) 42 { 43 int a,b; 44 scanf("%d %d",&a,&b); 45 Query(a,b); 46 } 47 return 0; 48 }
声明：我博客里有大量的从别的博客复制过来的代码，分析，以及理解，但我一律会在文章后面标记原博客大佬博客名，其中部分会加以连接。 绝无抄袭的意思，只是为了我在复习的时候找博客方便。 如有原作者对此有不满，请在博客留言，我一定会删除该博文。