ST表（C++实现）

本小白在学习线段树之前，先进行了ST表的学习，这个可以作为线段树的前置操作来学习

理解ST表的前置知识

可重复贡献问题

可重复贡献问题 是指对于运算 $opt$，满足 $xoptx=x$，则对应的区间询问就是一个可重复贡献问题。例如，最大值有 $max(x,x)=x$，$gcd$ 有 $gcd(x,x)=x$，所以 $RMQ$ 和区间 $gcd$就是一个可重复贡献问题。像区间和就不具有这个性质，如果求区间和的时候采用的预处理区间重叠了，则会导致重叠部分被计算两次，这是我们所不愿意看到的。另外，$opt$ 还必须满足结合律才能使用 ST 表求解。

以上这段来自于 $oi-wiki$ 对于可重复贡献问题的讲解，接下来说说 我的理解：

其实可重复贡献问题的意思就是，对于每一个你取到的元素来说，多次进行 $opt$ 运算并不影响最终的答案，举个例子，对于 $arr[5]=[1,2,3,4,5]$ 这个数组来说，如果我们要求这个数组的最大值，即便我在运算中多算了几次 $arr[1]$，都是不会影响到我最终的结果是 $5$ 的，反之，如果我要算这个数组的前缀和，在计算以 $arr[2]$ 为区间末尾的前缀和时，如果多加了几次 $arr[1]$ 那么最终的答案将会出现错误。由此看来，区间最大值就是一个可重复贡献问题，而区间和就不是。

（好理解点了吗？）

倍增

（这个是本算法的实现原理，如果想直接使用可以直接看正文啦）

什么是倍增？

顾名思义，也就是不停地翻倍。它能够使线性的处理转化为对数级的处理，大大地优化时间复杂度。

举个例子也许就明白啦：

如何用尽可能少的砝码称量出 $[0,1048575]$ 之间的所有重量？（只能在天平的一端放砝码)

答案其实很简单，就是选择重量为 $1,2,4,8,...,2^{19}$ 的砝码即可，从 $1048575$ 变成了 $20$ ，有没有体会到倍增的作用呢。

而且即便我们将重量翻倍增加，我们也只需要多加一个砝码，这是「对数级」的增长速度，因为砝码的个数和 $lo{g}_2(weight)$ 成正比

倍增的应用

这里我们不多说，说个最常用的吧（毕竟不是主要讲倍增）：快速幂

我们要求出 $a^n$ 这样的问题，这里的 $n$ 很可能是一个非常大的数字，如果我们使用如下代码：

int qpow(int a, int n){
      int ans = 1;
      while(n--){
          ans *= a;
      }
      return ans;
 }

不用怀疑的是，确实能做，但是复杂度是 $O(n)$ 级别的，并非最优解，而快速幂的目的是达到 $O(logn)$，从而给你的其他算法空出一些时间来。

快速幂做法很好懂：$a^n=(a^{n/2}{)}^2\ast a^{n\%2}$ ，通过不断地将 $n/2$ ，我们把 $n$ 的规模降低为之前的一半，最终到 $n$ 为0或1的情况单独讨论，那么我们就得到了递归版本的快速幂：

int qpow(int a, int n)
    {
        if (n == 0) 
            return 1;
        else if (n % 2 == 1)
            return qpow(a, n - 1) * a;
        else //降低规模，开始递归 qpow(a,n/2)
        {
            int temp = qpow(a, n / 2);
            return temp * temp;
        }
    }

结束了前置知识以后，我们就开始ST表的学习

什么是ST表？

ST表(Sparse Table)，也就是稀疏表，是一种用来解决可重复贡献问题的数据结构，主要用来解决 **$RMQ$ （区间最大值/最小值查询）**问题，应用了倍增的思想，让其能够做到 $O(nlogn)$ 预处理，O(1) 来查询每个区间。

优点：查询速度比线段树都快

缺点：无法修改，根本改不了一点

ST表使用一个二维数组 $f[i][j]$ 来表示区间 $[i,i+2^j-1]$ 的询问答案，以下我们将以区间最大值来举例。

预处理

起始点是 $f[i][0]=a_i$ ，根据我们的定义，第二维就相当于倍增的时候走了 $2^j-1$ 步，那么就可以根据倍增的思路来写状态转移方程：$f[i][j]=max(f[i][j-1],f[i+2^{j-1}][j-1])$ ，理解不了的可以看一下图，$f[i][j-1]$ 就是从 $i$ 开始走 $2^{j-1}-1$ 步，那么后半段就是从 $i+2^{j-1}$ 开始，到 $i+2^j-1$ 结束

查询

查询的时候，我们要找到两个 $[l,r]$ 的子区间，由于之前说过是可重复贡献问题，因此这两个子区间哪怕重叠也没有关系，只要两个子区间的并集是 $[l,r]$ ，我们就能够得到正确的结果

那么，为了避免选择错误的麻烦，我们直接让前一个子区间的右端点尽可能靠近 $r$ ，后一个子区间的左端点尽可能靠近 $l$，那么当 $l+2^s-1=r$ 或 $r-2^s+1=l$ 时，我们能得到 $s=lo{g}_2(r-l+1)$ ，但我们知道 $s$ 为整数，因此 $s=\lfloor lo{g}_2(r-l+1)\rfloor$

小tips：因为这里的 $log$ 其实还是比较花时间的，因此我们也可以提前进行预处理 $log$

废话不再多说了，进入show code环节

模板（洛谷P3865）

题目背景

这是一道 ST 表经典题——静态区间最大值

请注意最大数据时限只有 0.8s，数据强度不低，请务必保证你的每次查询复杂度为 $O(1)$。若使用更高时间复杂度算法不保证能通过。

如果您认为您的代码时间复杂度正确但是 TLE，可以尝试使用快速读入：

inline int read()
{
	int x=0,f=1;char ch=getchar();
	while (ch<'0'||ch>'9'){if (ch=='-') f=-1;ch=getchar();}
	while (ch>='0'&&ch<='9'){x=x*10+ch-48;ch=getchar();}
	return x*f;
}

函数返回值为读入的第一个整数。

快速读入作用仅为加快读入，并非强制使用。

题目描述

给定一个长度为 $N$ 的数列，和 $ M $ 次询问，求出每一次询问的区间内数字的最大值。

输入格式

第一行包含两个整数 $N,M$，分别表示数列的长度和询问的个数。

第二行包含 $N$ 个整数（记为 $a_i$），依次表示数列的第 $i$ 项。

接下来 $M$ 行，每行包含两个整数 $l_i,r_i$，表示查询的区间为 $[l_i,r_i]$。

输出格式

输出包含 $M$ 行，每行一个整数，依次表示每一次询问的结果。

样例 #1

样例输入 #1

8 8
9 3 1 7 5 6 0 8
1 6
1 5
2 7
2 6
1 8
4 8
3 7
1 8

样例输出 #1

9
9
7
7
9
8
7
9

提示

对于 $30\%$ 的数据，满足 $1\le N,M\le 10$。

对于 $70\%$ 的数据，满足 $1\le N,M\le {10}^5$。

对于 $100\%$ 的数据，满足 $1\le N\le {10}^5$，$1\le M\le 2\times {10}^6$，$a_i\in [0,{10}^9]$，$1\le l_i\le r_i\le N$。

AC代码：

#include<iostream>
#include<cmath> 
#include<stdio.h>
using namespace std;
int f[100005][30];
int a[100005];
int main(){
	int n,m;
	scanf("%d %d",&n,&m);
	// 输入每一个原数据，也就是f[i][0] 
	for(int i=1;i<=n;i++){
		scanf("%d", &f[i][0]);
	}
	// 动态规划处理 
	for(int j=1;j<=log2(m)+1;j++){
		for(int i=1;i+(1<<j)-1<=n;i++){
			f[i][j]=max(f[i][j-1],f[i+(1<<(j-1))][j-1]);
		}
	}
	// 查询开始 
	int l,r;
	for(int i=0;i<m;i++){
		scanf("%d %d", &l, &r);
		int s = log2(r-l+1); //找到s=log2(r-l+1) ，自动向下取整 
		// cout<<s<<" "<<f[l][s]<<" "<<f[r-(1<<s)+1][s]<<endl;
		printf("%d\n", max(f[l][s], f[r - (1 << s) + 1][s])); //查询 
	}
	return 0;
} 

以下是我自己随手的模板（鄙人更喜欢cin）

#include<iostream>
#include<cmath> 
using namespace std;
int f[10005][30];
int a[10005];
int main(){
	int n,m;
	cin>>n>>m;
	// 输入每一个原数据，也就是f[i][0] 
	for(int i=1;i<=n;i++){
		cin>>f[i][0];
	}
	// 动态规划处理 
	for(int j=1;j<=log2(m)+1;j++){
		for(int i=1;i+(1<<j)-1<=n;i++){
			f[i][j]=max(f[i][j-1],f[i+(1<<(j-1))][j-1]);
		}
	}
	// 查询开始 
	int l,r;
	for(int i=0;i<m;i++){
		cin>>l>>r;
		int s = log2(r-l+1); //找到s=log2(r-l+1) ，自动向下取整 
		// cout<<s<<" "<<f[l][s]<<" "<<f[r-(1<<s)+1][s]<<endl;
		cout<<max(f[l][s],f[r-(1<<s)+1][s])<<endl; //查询 
	}
	return 0;
} 

这是本算法小白对于ST表的理解，如有错误望各位指正，多谢！꒰ᐢ⸝⸝•༝•⸝⸝ᐢ꒱