RMQ_ST

#include<iostream>
#include<cmath>
using namespace std;
int dp[1000][1000],b[1000];
void rmq_st(int n)
{
  int i,j;
  for(i=1;i<=n;i++) dp[i][0]=b[i];
  int m=(int)(log(1.0*n)/log(2.0));
  for(j=1;j<=m;j++)
  {
    int t=n-(1<<j)+1;
    for(i=1;i<=t;i++)
      dp[i][j]=min(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
  }
}
int rmq_find(int l,int r)
{
  int k=(int)(log(1.0*(r-l+1))/log(2.0));
  return min(dp[l][k],dp[r+1-(1<<k)][k]);
}
int main()
{
  int n,i,l,r;
  cin>>n;
  for(i=1;i<=n;i++) cin>>b[i];
  rmq_st(n);
  while(cin>>l>>r) cout<<rmq_find(l,r)<<endl;
}




对于询问区间固定的情况,可以减少一维以降低空间,poj2823

#include<cstdio>
#include<iostream>
using namespace std;
int b[1000010],dmin[1000010],dmax[1000010];
int main()
{
    int n,k,i,j;
    scanf("%d%d",&n,&k);
    for(i=0;i<n;i++)
    {
        scanf("%d",&b[i]);
        dmax[i]=dmin[i]=b[i];
    }
    for(j=1;2*j<k;j*=2)
        for(i=0;i+j<n;i++)
        {
            dmin[i]=min(dmin[i],dmin[i+j]);
            dmax[i]=max(dmax[i],dmax[i+j]);
        }
    for(i=0;i<=n-k;i++) printf("%d ",min(dmin[i],dmin[i+k-j]));
    printf("\n");
    for(i=0;i<=n-k;i++) printf("%d ",max(dmax[i],dmax[i+k-j]));
}


### ST 表与 RMQ 问题 ST 表(Sparse Table)是一种用于解决静态数组上的区间最值查询(Range Minimum/Maximum Query, RMQ)的数据结构。它通过预处理的方式,在 $O(n \log n)$ 的时间复杂度下完成初始化,并支持在 $O(1)$ 时间内回答任意区间的最小值或最大值。 #### 预处理阶段 为了构建 Sparse Table,我们需要预先计算出对于每一个起点位置 `i` 和每种长度为 $2^j$ 的子区间内的最小值或最大值。具体来说: $$ f[i][j] = \min(f[i][j-1], f[i + 2^{j-1}][j-1]) $$ 或者 $$ f[i][j] = \max(f[i][j-1], f[i + 2^{j-1}][j-1]) $$ 其中,`f[i][j]` 表示从第 `i` 个元素开始的连续 $2^j$ 个数中的最小值或者最大值[^1]。 此过程可以通过动态规划来实现,其伪代码如下所示: ```python def preprocess_sparse_table(array): n = len(array) logn = int(math.log2(n)) + 1 st = [[0]*logn for _ in range(n)] # Initialize the base case (intervals of length 1). for i in range(n): st[i][0] = array[i] # Build sparse table. 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 ``` #### 查询阶段 一旦完成了上述预处理工作,则可以快速响应任何范围 `[L,R]` 上的最大值或最小值请求。我们只需要找到满足条件的最大整数 k ,使得 $2^k ≤ R-L+1$, 并比较两个重叠部分即可得出最终结果: $$ result = \min(\text{st}[L][k],\text{st}[R-(2^k)+1][k]) $$ 对于最大值情况则相应替换 $\min()$ 函数为 $\max()$. 下面是基于之前准备好的稀疏表执行实际查询的一个例子: ```python import math def query_min(L, R, st, n): k = int(math.log2(R - L + 1)) return min(st[L][k], st[R - (1 << k) + 1][k]) # Example Usage: array = [4,7,9,7,8,3,2] st = preprocess_sparse_table(array) print(query_min(1, 5, st, len(array))) # Output should be minimum value between index 1 to 5 inclusive. ``` 这种技术非常适合那些数据不会改变的应用场景之中,因为它不提供修改操作的支持;但是当面对只读型大数据集时,它的效率是非常高的。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值