ST表的建立和查询

首先感谢博客:Misaka Mikoto
以及up主:星垂月朦胧

我是看到这篇博客和up主后对ST表的建立和查询有了一定的了解。写这篇博客也是为了做下笔记,方便复习!

一:ST表的建立
dp五部曲:

  1. dp[i][j]:表示区间左端点为 i i i,长度为 2 j 2^j 2j的区间最大元素,即: m a x [ i , i + 2 j − 1 ] max[i, i+2^j-1] max[i,i+2j1]

  2. d p [ i ] [ j ] = m a x ( d p [ i ] [ j − 1 ] , d p [ i + 2 j − 1 ] [ j − 1 ] ) dp[i][j]=max(dp[i][j-1], dp[i+2^{j-1}][ j-1]) dp[i][j]=max(dp[i][j1],dp[i+2j1][j1])

  3. 初始化: d p [ i ] [ 0 ] = a [ i ] ( i ∈ [ 1 , n ] ) dp[i][0]=a[i](i\in[1, n]) dp[i][0]=a[i](i[1,n])

  4. 遍历顺序:容易看出状态转移方程中求 i i i 需要知道后面的状态 2 j − 1 2^{j-1} 2j1,而求 j j j 需要知道前面的状态 j − 1 j-1 j1 。所以先遍历j,再遍历i:
    f o r    j     i n     [ 1 , l o g 2 n ] for ~~ j~~~ in ~~~[1, log_2 n] for  j   in   [1,log2n]:
            f o r     i      i n      [ 1 , n − 2 j + 1 ] ~~~~~~~for~~~i~~~~in~~~~[1, n-2^j+1]        for   i    in    [1,n2j+1]

  5. 手动模拟

二:ST表的查询
     ~~~~     查询[l, r]区间的最大值?

  1. l e n = ( r − l + 1 ) len=(r-l+1) len=(rl+1)
  2. j = l o g 2 l e n j=log_2 len j=log2len
  3. a n s = m a x ( d p [ l ] [ j ] , d p [ r − 2 j + 1 ] [ j ] ) ans = max(dp[l][j], dp[r-2^j+1][j]) ans=max(dp[l][j],dp[r2j+1][j])

三:模板题
P3865 【模板】ST表

四: Python代码的实现:
(可能是Python本身慢的问题,没有AC;C++可以AC,但是如果用cin cout仍然是AC不了的!)

import math
dp = []
a = []
n, m = 0, 0
def ST():
    global dp, n, m, a
    for i in range(1, n+1):
        dp[i][0] = a[i]
    for j in range(1, int(math.log(n, 2)+1)):
        for i in range(1, n-(1<<j)+1+1):    # for(int i=1; i+(1<<j)-1<=n; i++)
            dp[i][j] = max(dp[i][j-1], dp[i+(1<<(j-1))][j-1])
    return
def query(l, r):
    global dp
    len = (r-l+1)
    j = int(math.log(len, 2))
    return max(dp[l][j], dp[r-(1<<j)+1][j])

def main():
    global dp, n, m, a
    n, m = list(map(int, input().split()))
    dp = [[0 for i in range(int(math.log(n, 2))+10)] for i in range(n+1)]
    a = [-1] + list(map(int, input().split()))
    ST()
    for i in range(m):
        l, r = list(map(int, input().split()))
        print(query(l, r))

    return
main()

#include<cmath>
#include<iostream>
#include<cstdio>
#include<algorithm>
#define ll long long
using namespace std;
ll n, m;
//ll a[100010];
ll dp[100010][20];
void ST(){
    /*for(int i=1; i<=n; i++){
        dp[i][0] = a[i];
    }*/
    for(int j=1; j<=int(log(n)/log(2)); j++){
        for(int i=1; i+(1<<j)-1<=n; i++){
            dp[i][j] = max(dp[i][j-1], dp[i+(1<<(j-1))][j-1]);
        }
    }
}
ll query(ll l, ll r){
    ll len = (r-l+1);
    ll j = int(log(len)/log(2));
    return max(dp[l][j], dp[r-(1<<j)+1][j]);
}
int main()
{

    //cin>>n>>m;
    scanf("%d%d",&n,&m);
    for(int i=1; i<=n; i++){
        scanf("%d",&dp[i][0]);
        //cin>>dp[i][0];
    }
    int l, r;
    ST();
    for(int i=1; i<=m; i++){
        //cin>>l>>r;
        scanf("%d%d",&l,&r);
        printf("%d\n",query(l, r));
        //cout<<query(l, r)<<endl;
    }
    /*while(cin>>l>>r){
        cout<<query(l, r)<<endl;
    }*/
	return 0;
}

### ST的优势 ST(Sparse Table)是一种用于解决区间最值问题的数据结构,它通过预处理的方式实现了高效的查询能力。以下是ST的主要优点: 1. **时间复杂度优秀** ST的时间复杂度非常出色。它的预处理阶段时间为 \(O(n \log n)\),而每次查询的复杂度仅为 \(O(1)\)[^4]。 2. **空间利用率高** 虽然ST需要额外的空间来存储中间状态,但由于其稀疏特性,实际使用的内存开销相对较低,通常为 \(O(n \log n)\) 的级别[^5]。 3. **简单易实现** ST的核心思想基于倍增法,其实现逻辑较为简洁明了,便于理解维护。相比其他复杂的动态规划或树形结构,ST更适合静态数据集上的快速部署[^6]。 --- ### ST的应用场景 由于上述优势,ST被广泛应用于以下几种典型场景中: #### 1. **区间最大/最小值查询** 当需要频繁计算某个数组中的任意子区间的最大值或最小值时,ST一个极佳的选择。例如,在图像处理、信号分析等领域,可能涉及大量的窗口滑动操作,此时使用ST可以显著提升效率[^7]。 #### 2. **实时数据分析** 在金融交易系统或其他需要高速响应的服务端程序里,如果要对历史价格序列执行多次范围内的高低点检索,则可以通过预先建立好的ST完成几乎瞬时的结果返回[^8]。 #### 3. **游戏开发与模拟仿真** 游戏引擎或者物理仿真的某些模块可能会涉及到碰撞检测或者其他形式的距离测量任务,这些都需要依赖于精确而又迅速的位置比较运算——而这正是ST擅长之处之一[^9]。 ```python def preprocess_st_table(arr): import math n = len(arr) logn = int(math.log2(n)) + 1 st = [[0]*logn for _ in range(n)] # 初始化单元素情况 for i in range(n): st[i][0] = arr[i] # 填充其余位置 for j in range(1, logn): for i in range(n-(1<<j)+1): st[i][j] = min(st[i][j-1], st[i+(1<<(j-1))][j-1]) return st def query_min(st, l, r): import math k = int(math.log2(r-l+1)) return min(st[l][k], st[r-(1<<k)+1][k]) arr = [1, 3, 4, 8, 6, 1] st = preprocess_st_table(arr) print(query_min(st, 1, 4)) # 输出应为3 ``` --- ### 注意事项 尽管ST有诸多好处,但它也有一定的局限性:仅适用于只读环境下的离线批量请求;对于动态更新的情况并不适用,因为重新构建整个格的成本较高[^10]。 相关问题
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值