RMQ（ST算法）

Posted 2022-05-18 jiamian

概述：

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)=maxF[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\n",get_min(a,b,0,0,n)==INF?-1:get_min(a,b,0,0,n));
54 

View Code

时间复杂度

预处理时,操作的节点个数为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\n",F[LCA(pos[u],pos[v])]);
70     
71     return 0; 
72 

View Code

原文：https://blog.csdn.net/xuzengqiang/article/details/7350465

---