ST算法

Posted 2021-01-20 ycourage

　　ST算法用于解决RMQ（Range Minimum/Maximum Query）的问题。解决RMQ有三种实现的方法： 1.基于分治的树状数组  2.基于分治的线段树  3.动态规划下的ST表算法。点这里查看它们的复杂度和区别。ST算法无法修改、O(1)的查询、O(nlogn)的预处理；

　　分析数组a的区间最小值。约定数组 a_1~10 ：4 7 9 6 3 2 8 5 1 6

O（ nlog_n ）的预处理

　　用 dp[ i ] [ j ] 表示 从 i 位置开始，长度为 2 ^ ^j （下文也称步长）这一段的最小值。dp [ 3 ] [ 2 ]=min（a₃~a_3+4-1），dp [ 2 ] [ 3 ]=min（a₂~a_2+8-1）。如 dp[ 4 ] [ 2 ] 表示从 4 位置（即数字 6），长度为 4（2 ^ ²）的最小值，即 6 3 2 8 的最小值，显然 dp[ 4 ] [ 2 ] =2；

　　求dp[ ] [ ] 数组的过程是：

　　先求 dp[ i ] [ 0 ] ，再求 dp [ i ] [ 1 ]，再求 dp [ i ] [ 2 ]，再求 dp [ i ] [ 3 ] …… 这里的 i 定会满足 i+2 ^ ^j -1 <= 10（数组长度）^【1】，当然 dp[ i ] [ 0 ]=a _i 

　　对于 dp [ 1 ] [ 2 ] ，该如何求？由于长度2 ^ ^j （j>1）总是可 一半一半 的，所以对于步长2 ^ ^j 的一段来说，我们分两等长段，两段中各自最小值的较小者，就是整段的最小值

　　不难证明 dp [ 1 ] [ 2 ] = min（dp [ 1 ] [ 1 ]，dp [ 1+2 ] [ 1 ] ）

　　　　即：min（a₁~a₄）=min（ min（a₁~a₂），min（a₃~a₄））

　　推到一般情况，再巧用位运算（和乘除运算同级，写的时候要格外注意） dp [ i ] [ j ] = min（dp [ i ] [ 1<<(j-1) ]，dp [ i+1<<(j-1) ] [ 1<<(j-1) ] ）

　　前面说到 先求 dp [ i ] [ 1 ]，再求 dp [ i ] [ 2 ]，再求 dp [ i ] [ 3 ]……因此 每一个 i 循环结束，才会进行 j 循环。从式子也能看出，正是得到了 每个 dp[ i ] [ j-1 ]，我们才能得到 dp [ i ] [ j ]。因此 j 循环是外层循环，i 是内层。

void pre_set()
{
    for(int i=1;i<=n;i++)
        dp[i][0]=a[i];
    for(int j=1;j<20;j++)
    {
        for(int i=1;i+(1<<j)-1<=n;i++)
        {
            dp[i][j]=min(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
        }
    }
}

pre_set()

O（1）的查询

　　ST算法不能修改，但有O（1）的查询。现有查询 query( l , r ) （区间长度 r - l + 1 ），如何使用dp [ ] [ ] 数组，快速得到答案？——计算这样的 k ，2 ^{^ k}= ( r - l + 1 )，如果 k 刚好为整数，那么dp [ l ] [ k ] 就是答案，比如 query( 3 , 6 )，则 k = 2，dp [ 3 ] [ 2 ] =min（a₃~a_3+4-1）= 2 就是答案；可数据随机的话，肯定大部分的 k 都不是整数，那么就没有 dp [ l ] [ x ] 刚好对应 r - l + 1 这个长度，但是可以从区间左右端点开始找相同步长的两个 dp 值，比如 query ( 2 , 10 ) = min（ a₂ ~ a₁₀ ），找不到整数 k 满足那个式子，但是 min（ a₂ ~ a₁₀ ）= min（ min（ a₂ ~ a₉ ），min（ a₃ ~ a₁₀ ）），这样两段都有确切的 dp 值了。此时的步长需要非整数 k 向下取整（这两段是不能隔断的，k = floor ( log2( r - l + 1) ，），因为满足 2 ^{^ k} > ( r - l + 1 ) 的 k ，dp [ l ] [ k ] 的值牵扯到 [ l , r ] 之外的 a 值，是不可能的。当 k 为整数时，分的两段是相同的，不影响结果，可一并考虑。

void query(int l,int r)
{
    int k=0;
    while(1<<(k+1)<=r-l+1)
        k++;
    return min(dp[l][k],dp[r-(1<<k)+1][k]);
}

query()

　　当数据规模非常大时，每次这样找 k 是不行的，浪费很多时间，所以就可以预处理出每个 k ，代码如下：

void lg_init()
{
    lg[0]=-1;
    for(int i=1;i<M;i++)
        lg[i]=lg[i>>1]+1;
}

lg_init()

 最后，整个算法

const int M=1e5+5;

int n;
int a[n];
int lg[M];
int dp[M][20];

void pre_set()
{
    for(int i=1;i<=n;i++)
        dp[i][0]=a[i];
    for(int j=1;j<20;j++)
    {
        for(int i=1;i+(1<<j)-1<=n;i++)
        {
            dp[i][j]=min(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
        }
    }
}

void lg_init()
{
    lg[0]=-1;
    for(int i=1;i<M;i++)
        lg[i]=lg[i>>1]+1;
}

void query(int l,int r)
{
    int k=lg[r-l+1];
    return min(dp[l][k],dp[r-(1<<k)+1][k]);
}

RMQ