Sparse Table

Sparse Table 可用于解决这样的问题：给出一个 $n$ 个元素的数组 $a_1,a_2,\cdots ,a_n$，支持查询操作计算区间 $[l,r]$ 的最小值（或最大值）。这种问题被称为区间最值查询问题（Range Minimum/Maximum Query，简称 RMQ 问题）。预处理的时间复杂度为 $O(n\log n)$，预处理后数组 $a$ 的值不可以修改，一次查询操作的时间复杂度为 $O(1)$。

例题：P2880 [USACO07JAN] Balanced Lineup G

有一个包含 $n$ 个数的序列 $h_i$，有 $q$ 次询问，每次询问 $h_{a_i},h_{a_i+1},\cdots ,h_{b_i-1},h_{b_i}$ 中最大值与最小值的差。
数据范围：$1\le n\le 5\times {10}^4,1\le q\le 1.8\times {10}^5,1\le h_i\le {10}^6,a_i\le b_i$。

分析：题目要求最大值和最小值的差难以直接求出，通常需要分别求解最大值和最小值。最直接的做法是每次遍历区间中的每一个数，记录最大值和最小值。这样可以正确求出正确答案，但是效率低下，时间复杂度高达 $O(nq)$，无法通过本题。

之所以这样做效率低下，是因为所有询问区间可能有着大量的重叠，这些重叠部分被多次遍历到，因此产生了大量的重复。如果可以通过预处理得到一些区间的最小值，再通过这些区间拼凑每一个询问区间，就可以提高效率。

预处理前缀和可以拼凑出任意区间的和，但是这个思路不能直接搬到最值查询问题中。原因在于区间和可以从一个大区间中减去一部分小区间得到，而区间最值不行，所以只能用小区间去拼出大区间。如何选择预处理的区间就成为关键，选择的区间既要能够拼出任意区间，数量少又不能太多，并且预处理和查询都要高效。

可以预处理以每一个位置为开头，长度为 $2^0,2^1,\cdots ,2^{\lfloor {\log }_{2}n\rfloor }$ 的所有区间最值。下面以最大值为例，用 $f_{i,j}$ 表示 $h_i,h_{i+1},\cdots ,h_{i+2^j-2},h_{i+2^j-1}$ 中的最大值，用递推的方式计算所有的 $f$，转移为 $f_{i,j}=max(f_{i,j-1},f_{i+2^{j-1},j-1})$。计算所有的 $f$ 的过程为预处理，预处理的时间复杂度为 $O(n\log n)$。

void init() {
	for (int i = 1; i <= n; i++) {
		f[i][0] = h[i];
	}
	for (int j = 1; (1 << j) <= n; j++) {
		for (int i = 1; i <= n - (1 << j) + 1; i++) {
			f[i][j] = max(f[i][j - 1], f[i + (1 << (j - 1))][j - 1]);
		} 
	}
}

接下来解决查询的问题，设需要查询最大值的区间是 $[l,r]$。记区间长度为 $L$，则该区间可以拆分为 $O(\log L)$ 个小区间。对 $L$ 做二进制拆分，从 $l$ 开始向后跳，每次跳跃的量是一个 $2$ 的幂，从而拼出整个区间。单词查询时间复杂度为 $O(\log n)$。

int query(int l, int r) {
	int len = r - l + 1, ans = -INF, cur = l;
	for (int i = 0; (1 << i) <= len; i++) {
		if ((len >> i) & 1) {
			ans = max(ans, f[cur][i]);
			cur += (1 << i);
		} 
	}
	return ans;
}

更进一步，查询区间最值时，区间合并的过程允许重叠，因此只需要找到两个长度为 $2^k$ 的区间合并得到 $[l,r]$。令 $k$ 为满足 $2^k\le r-l+1$ 的最大整数，区间 $[l,l+2^k-1]$ 和区间 $[r-2^k+1,r]$ 合并起来覆盖了需要查询的区间 $[l,r]$。

int query(int l, int r) {
	int k = log_2[r - l + 1]; // 可以预处理log_2的表
	return max(f[l][k], f[r - (1 << k) + 1][k]);
}

参考代码

#include <cstdio>
#include <algorithm>
using std::min;
using std::max;
const int N = 50005;
const int LOG = 16;
int h[N], f_min[N][LOG], f_max[N][LOG], log_2[N];
void init(int n) {
    log_2[1] = 0;
    for (int i = 2; i <= n; i++) log_2[i] = log_2[i >> 1] + 1; // 预处理对数表
    for (int i = 1; i <= n; i++) {
        f_min[i][0] = f_max[i][0] = h[i];
    }
    for (int j = 1; (1 << j) <= n; j++) {
        for (int i = 1; i <= n - (1 << j) + 1; i++) {
            f_min[i][j] = min(f_min[i][j - 1], f_min[i + (1 << (j - 1))][j - 1]);
            f_max[i][j] = max(f_max[i][j - 1], f_max[i + (1 << (j - 1))][j - 1]);
        }
    }
}
int query(int l, int r, int flag) { // flag为1时查询最大值，为0时查询最小值
    int k = log_2[r - l + 1];
    if (flag) return max(f_max[l][k], f_max[r - (1 << k) + 1][k]);
    else return min(f_min[l][k], f_min[r - (1 << k) + 1][k]);
}
int main()
{
    int n, q; scanf("%d%d", &n, &q);
    for (int i = 1; i <= n; i++) scanf("%d", &h[i]);
    init(n);
    for (int i = 1; i <= q; i++) {
        int a, b; scanf("%d%d", &a, &b);
        printf("%d\n", query(a, b, 1) - query(a, b, 0));
    }
    return 0;
}

Sparse Table 预处理部分的时间复杂度为 $O(n\log n)$，查询一次的时间复杂度为 $O(1)$，总的时间复杂度为 $O(n\log n)$。

Sparse Table 不仅可以求区间最大值和最小值，还可以处理符合结合律和幂等律（与自身做运算，结果仍是自身）的信息查询，如区间最大公约数、区间最小公倍数、区间按位或、区间按位与等。

例题：P7333 [JRKSJ R1] JFCA

分析：看到环形，先破环成链。

看起来每个点的答案 $O(1)$ 求得不太容易，但每个点的答案具有二分性。

对于每个点，二分答案，查询左右两段区间的最大值看是否大于等于 $b_i$。

因为没有修改，所以区间最值可以用 Sparse Table 维护，总体时间复杂度为 $O(n\log n)$。

参考代码

#include <cstdio>
#include <algorithm>
using std::max;
using std::min;
const int N = 300005;
const int LOG = 17;
int a[N], b[N], log_2[N], st[N][LOG], ans[N];
int query(int l, int r) {
    int len = log_2[r - l + 1];
    return max(st[l][len], st[r - (1 << len) + 1][len]);
}
int main()
{
    int n; scanf("%d", &n);
    for (int i = 2; i <= n; i++) log_2[i] = log_2[i / 2] + 1;
    for (int i = 1; i <= n; i++) {
        // 破环成链
        scanf("%d", &a[i]); a[i + n * 2] = a[i + n] = a[i];
        st[i][0] = st[i + n][0] = st[i + n * 2][0] = a[i];
        ans[i] = n;
    }
    // Sparse Table 维护区间最大值
    for (int j = 1; (1 << j) <= n; j++) {
        for (int i = 1; i <= 3 * n - (1 << j) + 1; i++) {
            st[i][j] = max(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
        }
    }
    for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
    for (int i = n + 1; i <= n * 2; i++) {
        // left 二分左边第一个位置
        int l = i - n + 1, r = i - 1, res = -1;
        while (l <= r) {
            int mid = (l + r) / 2; 
            if (query(mid, i - 1) >= b[i - n]) {
                l = mid + 1; res = mid;
            } else {
                r = mid - 1; 
            }
        }
        if (res != -1) ans[i - n] = min(ans[i - n], i - res);
        // right 二分右边第一个位置
        l = i + 1; r = i + n - 1; res = -1;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (query(i + 1, mid) >= b[i - n]) {
                r = mid - 1; res = mid;
            } else {
                l = mid + 1;
            }
        }
        if (res != -1) ans[i - n] = min(ans[i - n], res - i);
    }
    for (int i = 1; i <= n; i++) printf("%d ", ans[i] == n ? -1 : ans[i]);
    return 0;
}