RMQ

问题描述

　　给定一个长度为 n 的数列 a。
　　随后有 q 次询问，每次询问给定一个区间，请回答区间的最小值。

输入格式

　　第一行一个正整数n，表示数列长度。
　　第二行n个非负整数，表示数列a。
　　第三行一个正整数q，表示询问数量。
　　随后q行，每行两个正整数x、y，表示询问区间。

输出格式

　    共q行，每行一个整数，表示区间的最小值。

输出格式

5
2 1 3 5 4
3
1 1
1 3
3 5

样例输出 

2
1
3

数据规模和约定

　　n, q <= 100000，a数组元素 <=  

RMQ

RMQ 是什么:

RMQ 表示区间最大/小值。

在接下来的描述中，默认初始数组大小为 n，询问次数为 m。 

CODE：

1.ST表 O(m log m)～O(log n)

1.预处理

st[i][0]=a[i];
for(int j=1;j<=log2(n);j++){
    int len=(1<<j);
    for(int i=1;i+len-1<=n;i++){
        st[i][j]=min(st[i][j-1],st[i+len/2][j-1]);
    }
}

2.求值

int x=log2(r-l+1);
int len=(1<<x);
int ans=min(st[l][x],st[r-len+1][x]);

3.最终代码

#include <bits/stdc++.h>
using namespace std;
int n,m,t,a[100010],st[100010][20],l,r;
int main(){
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];
        st[i][0]=a[i];
    }
    m=log2(n);
    for(int j=1;j<=m;j++){
        int len=(1<<j);
        for(int i=1;i+len-1<=n;i++){
            st[i][j]=min(st[i][j-1],st[i+len/2][j-1]);
        }
    }
    cin>>t;
    for(int i=1;i<=t;i++){
        cin>>l>>r;
        int x=log2(r-l+1);
        int len=(1<<x);
        int ans=min(st[l][x],st[r-len+1][x]);
        cout<<ans<<endl;
    }
    return 0;
}

 2.分块 O(+2*q)

#include<bits/stdc++.h>
using namespace std;
int n,a[100010],t[100010],l,r,x=100;
int main(){
    int i,j;
    cin>>n;
    for(i=1;i<=n;i++){
        cin>>a[i];
    }
    int nt=n/x;
    for(i=0;i<nt;i++){
        int s=a[i*x];
        for(j=i*x;j<i*x+x;j++){
            if(a[j]<s){
                s=a[j];
            }
        }
        t[i]=s;
    }
    int q;
    cin>>q;
    for(i=1;i<=q;i++){
        int l,r,s;
        cin>>l>>r;
        s=a[l];
        if(r-l<=x){
            for(j=l;j<=r;j++){
                if(a[j]<s){
                    s=a[j];
                }
            }
        }
        else{
            int ee=l/x*x+x;
            for(j=l;j<ee;j++){
                if(a[j]<s){
                    s=a[j];
                }
            }
            for(j=l/x+1;j<r/x;j++){
                if(t[j]<s){
                    s=t[j];
                }
            }
            for(j=r/x*x;j<=r;j++){
                if(a[j]<s){
                    s=a[j];
                }
            }
        }
        cout<<s<<endl;
    }
    return 0;
}

注意：以下为进阶算法，需要较高基础

Four Russian

这个算法不太出名。

Four russian 是一个由四位俄罗斯籍的计算机科学家提出来的基于 ST 表的算法。

改进:序列分块。

具体来说，我们将原数组——我们将其称之为数组 A——每 S 个分成一块，总共 n/S 块。

对于每一块我们预处理出来块内元素的最小值，建立一个长度为 n/S 的 ST 表数组 B。

同时，我们对于数组 A 的每一个零散块也建立一个 ST 表。

询问的时候，我们可以将询问区间划分为不超过 1 个数组 B 上的连续块区间和不超过 2 个数组 A 上的整块内的连续区间。显然这些问题我们通过 ST 表上的区间查询解决。

在 S=log⁡ n 时候，预处理复杂度达到最优，为 O(n log ⁡log⁡ n)。

时间复杂度 O(n log ⁡log⁡ n)∼O(1)

空间复杂度 O(n log ⁡log⁡ n)

注意：常数较大。

一些小的的算法改进

在询问的两个端点在数组 A 中属于不同的块的时候，数组 A 中块内的询问是关于每一块前缀或者后缀的询问。

显然这些询问可以通过预处理答案在 O(n) 的时间复杂度内被解决。这样子我们只需要在询问的时候进行至多一次 ST 表上的查询操作了。

一些玄学的算法改进

我们将块大小设为 ，然后预处理出每一块内前缀和后缀的 RMQ，再暴力预处理出任意连续的整块之间的 RMQ，时间复杂度为 O(n)。

查询时，对于左右端点不在同一块内的询问，我们可以直接 O(1) 得到左端点所在块的后缀 RMQ，左端点和右端点之间的连续整块 RMQ，和右端点所在块的前缀 RMQ，答案即为三者之间的最值。

而对于左右端点在同一块内的询问，我们可以暴力求出两点之间的 RMQ，时间复杂度为 O()，但是单个询问的左右端点在同一块内的期望为 O()，所以这种方法的时间复杂度为期望 O(n)。

由于善（du）良（liu）的CCF不卡常了，因为我们可以通过在  的基础上随机微调块大小，很大程度上避免算法在根据特定块大小构造的数据中出现最坏情况。

非常好用！！！

加 1 减 1 RMQ

若序列满足相邻两元素相差为 1，可以做到 O(n)∼O(1) 的时间复杂度，O(n) 的空间复杂度。

重点在于块内 RMQ 问题的优化。

由于相邻两个数字的差值为 ±1，所以在固定左端点数字时 长度不超过 log⁡ n 的右侧序列种类数为 <=n。

由于 ≤n 这我们可以预处理所有不超过 log n 种情况的最小值 − 第一个元素 的值。

在预处理的时候我们需要去预处理同一块内相邻两个数字之间的差，转换成二进制。在询问的时候我们找到询问区间对应的二进制表示进行查询，来得出答案。

预处理的时间复杂度就被优化到了 O(n)。