ST表（解决RMQ问题）

有点时间补一下这玩意吧。

首先先说明 RMQ 是一类问题，指 区间最值问题，而 ST 表是解决 RMQ 问题的一把手术刀（手术刀，锋利但不通用）。

作用

$O(\log n)$ 的预处理。
$O(1)$ 的区间最值查询。
不可以更改区间数值。

原理

原理是倍增。

我们将设 $f[i][j]$ 是从 $i$ 处向外包含 $2^j$ 个数中的最大值。即 $[i,i+2^j-1]$ 中的最大值，原数组为 $a[i]$，其中 $f[i][0]=a[i]$。

因为任何区间长度 $len$，无论怎么分，其最多只需要两个 $f[i][j]$ 就可以完全覆盖它。

证明：区间长度 $len$，可以分出一个比 $len$ 小的最大的 $2^n$，那么 $len-2^n<2^n$， 如果不符合这个的话, $n$ 就可以继续往上增加直到出现上述情况。因此一定有一个 $n$ 使得 $len-2^n<2^n$ 成立，而 $f[i][j]$ 的覆盖的长度为 $2^j$，只要让 $j$ 等于上面的 $n$，就可以最多用两个 $f$ 可以覆盖其范围，且不会超出边界。也可以知道 $n$ 就等于 $\lfloor {\log }_{2}len\rfloor$。

根据上面的证明我们也就知道如何去查询了，设 $f_1$ 一定包含这个区间的开头，$f_2$ 一定包含这个区间的末尾。大致如下图。
![[ST表.png|475]]
设这个区间为 $[i,j]$，那么区间长度 $len$ 就是 $j-i+1$，证明中说到的 $n$ 就等于 ${\log }_{2}len$
由图可知 $f_1$ 包含的区间就是 $[i,i+2^n-1]$，$f_2$ 就是 $[j-2^n+1,j]$。对应 $f$ 数组就是 $f[i]i+2^n-1]$ 和 $f[j-2^n+1][j]$。

实现

问题来了怎么实现它。

预处理

也很简单，根据之前倍增 $LCA$ 的思想（没学过也可以），我们把一步拆成两步走，即先跳 $2^{j-1}$ 步再跳 $2^{j-1}$ 步，可得出递推式 $f[i][j]=f[f[i][j-1]][j-1]$，有了递推式, 那么求出它就很简单了。

而求出 ST 表, 也就是预处理就是下面代码

for (int j = 0; j < M; j ++ ) // M是logn上取整, 即包含整个n
	for (int i = 1; i + (1 << j) - 1 <= n; i ++ )
		if (j == 0) f[i][j] = w[i]; // 如果只跳一步, 那么最大值就是这个值它本身
		else f[i][j] = max(f[i][j], f[f[i][j - 1]][j - 1]); // 注意是求最大值

这个时间复杂度很好判断, 最坏 $O(n\log n)$，但是是很小的 $\log n$，能从循环中看出来（手术刀）因为有预处理，所以是不能更改原数组的，否则必须再次预处理（但这样就不如用线段树了）。

$lg$ 数组

上面提到了 $lg$ 数组，$lg[i]$ 为 ${\log }_{2}i$ 下取整。

为什么使用这个数组而不是, 直接用函数 $\log 2()$ 呢?

这里是为了保证查询的 $O(1)$，如果调用 $log2()$ 函数的话，时间复杂度会增加, 而通过预处理
$lg$ 数组的方式，就可以保证查询 $O(1)$。

$lg$ 数组一般预处理一遍即可，是 $O(n\log n)$ 的时间复杂度，不会影响整体的预处理时间复杂度，可以直接加在上面的预处理里面。

查询

怎么查询呢？
你要知道, 最大值的区间是可以重叠的, 如 $[1,5]$ 的最大值, 等于 $[1,3]$ 的最大值和 $[2,5]$ 的最大值的最大值, 虽然区间重叠了，但不影响答案的正确性，即最大值的区间是可以重叠的。

我们已经得到了 $f_1,f_2$ （在上面原理中），根据上面的性质，那么就很简单了。
我们设 $lg[i]$ 为 $\lfloor {\log }_{2}i\rfloor$ ，那么从 $i$ 到 $j$ 之间的长度是 $len=j-i+1$，最大值就是 $\max (f[i][lg[len]],f[j-2^{lg[i]}+1][lg[len]])$。

其中 $j-2^{lg[i]}+1$ ，这是 $f_2$ 包含区间的开头，比如 $[2,5]$ 里面有 $4$ 个数，你从$5$ 减 $4$ 得 $1$，但是你的区间是从 $2$ 开始的，所以要加上 $1$。由区间 $[i,j]$ 长度计算公式 $j-i+1=len$ 也可以得到 $i=j-len+1$ 这个式子。

代码

上面的要快一点点，下面的更好写保证对，注意 $\log 2()$ 函数

int last = 0;
for (int i = 1; i <= n; i ++ )
{
	while (1 << last <= i) last ++ ; // 始终保证 2^last > i, 以便求出i的最小log2
	lg[i] = last - 1;
}

或者

for (int i = 1; i <= n; i ++ )
{
	lg[i] = log2(i);
}

例题

ST表(跳表)

/* 
    中心思想: 倍增
    设f[i][j]是从i处向外2^j格里面的最大值;
    
    预处理是O(nlogn)
    查询是O(1)的
    
    无法修改
    只能查询
    像树状数组一样的"手术刀"
    
    因为查询耗时O(1), 所以在"特殊情况"下没法被O(log)的线段树替代
*/

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>

using namespace std;

const int N = 200010, M = log2(N) + 1;

int n, m;
int w[N];
int f[N][M];
int lg[N];

void init()
{
    for (int j = 0; j < M; j ++ )
        for (int i = 1; i + (1 << j) - 1 <= n; i ++ )
            if (j == 0) f[i][j] = w[i];
            else f[i][j] = max(f[i][j - 1], f[i + (1 << j - 1)][j - 1]);

    int last = 0;
    for (int i = 1; i < N; i ++ ) // log数组, 这里的预处理是自己写的, 利用一个last能干好多事
    {
        while (1 << last <= i) last ++ ;
        lg[i] = last - 1;
    }
}

int query(int l, int r)
{
    int len = r - l + 1;
    return max(f[l][lg[len]], f[r - (1 << lg[len]) + 1][lg[len]]);
}

int main()
{
    cin >> n;
    for (int i = 1; i <= n; i ++ ) cin >> w[i];
    init();
    cin >> m;
    while (m -- )
    {
        int a, b;
        cin >> a >> b;
        cout << query(a, b) << endl;
    }
    
    return 0;
}

线段树

/*
    线段树的话, 比较简单就不打注释了
*/
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>

using namespace std;

const int N = 200010;

int w[N];
int n, m;

struct Node
{
    int l, r;
    int maxv;
}tr[N * 4];

void pushup(int u)
{
    tr[u].maxv = max(tr[u << 1].maxv, tr[u << 1 | 1].maxv);
}

void build(int u, int l, int r)
{
    if (l == r) tr[u] = {l, l, w[l]};
    else
    {
        int mid = l + r >> 1;
        tr[u] = {l, r, -0x3f3f3f3f};
        build(u << 1, l, mid);
        build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

int query(int u, int l, int r)
{
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].maxv;
    else
    {
        int mid = tr[u].l + tr[u].r >> 1;
        int maxv = -0x3f3f3f3f;
        if (l <= mid) maxv = query(u << 1, l, r);
        if (r > mid) maxv = max(maxv, query(u << 1 | 1, l, r));
        
        return maxv;
    }
}

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &w[i]);
    build(1, 1, n);
    scanf("%d", &m);
    
    while (m -- )
    {
        int l, r;
        scanf("%d%d", &l, &r);
        printf("%d\n", query(1, l, r));
    }
    return 0;
}