菜鸟系列——Sparse Table

最新推荐文章于 2023-01-01 22:52:28 发布
最新推荐文章于 2023-01-01 22:52:28 发布
阅读量501 收藏
点赞数
分类专栏： 菜鸟系列 文章标签： acm poj
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kopyh/article/details/46449583
版权
做回菜鸟，老老实实重新学起：

Sparse Table

一维：

构造RMQ数组:

ST(int n)   O(nlog(n))的算法复杂度
dp[i][j] 表示从i到i+2^j -1中最小的一个值(从i开始持续2^j个数)
dp[i][j]=max{dp[i][j-1],dp[i+2^(j-1)][j-1]}
查询RMQ:

RMQ(int i,int j)
将i-j 分成两个2^k的区间
即 k=(int)log2(i-j+1)
查询结果应该为 max(f2[i][k],f2[j-2^k+1][k])

int dp[N][35],num[N];
void ST(int n)
{
    for(int i=0;i<n;i++)
        dp[i][0] = num[i];//递推的初值

    int k = (int)(log((double)n) / log(2.0));
    for(int j=1;j<=k;j++)//自底向上递推
    {
        for(int i=0;i+(1<<j)-1<n;i++)
        {
            int m = i+(1<<(j-1));//求出中间的那个值
            dp[i][j] = max(dp[i][j-1], dp[m][j-1]);
        }
    }
}
int RMQ(int l,int r)//查询i和j之间的最值,注意i是从0开始的
{
    int mid = (int)(log((double)(r-l+1)) / log(2.0));
    int t = max(dp[l][mid],dp[r-(1<<mid)+1][mid]);
    return t;
}


二维：

构造RMQ数组:

ST()   O(n*n*log(n)*log(n))的算法复杂度
dp[r][l][i][j] 表示从r到r+2^i -1和l到l+2^j-1中最小的一个值(从(r,l)到(r+2^i -1,l+2^j-1)的矩形)

int dp[N][N][32][32];//careful memory limit
int val[N][N];

void ST()
{
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            dp[i][j][0][0] = val[i-1][j-1];//递推的初值

    int k = (int)(log((double)n) / log(2.0));
    for(int i=0;i<=k;i++)
        for(int j=0;j<=k;j++)
        {
            if(i==0 && j==0)
                continue;
            for(int r=1;r+(1<<i)-1<=n;r++)
                for(int l=1;l+(1<<j)-1<=n;l++)
                {
                    if (i == 0) //只有一行时横向更新
                        dp[r][l][i][j] = max(dp[r][l][i][j-1], dp[r][l+(1<<(j-1))][i][j-1]);
                    else
                        dp[r][l][i][j] = max(dp[r][l][i-1][j], dp[r+(1<<(i-1))][l][i-1][j]);
                }
        }
}

int RMQ(int r,int l,int rr,int ll)
{
    int kr = (int)(log((double)(rr-r+1)) / log(2.0));
    int kl = (int)(log((double)(ll-l+1)) / log(2.0));

    int t1 = dp[r][l][kr][kl];
    int t2 = dp[rr-(1<<kr)+1][l][kr][kl];
    int t3 = dp[r][ll-(1<<kl)+1][kr][kl];
    int t4 = dp[rr-(1<<kr)+1][ll-(1<<kl)+1][kr][kl];
    return max(max(t1, t2), max(t3, t4));
}


查询RMQ:

RMQ(int i,int j)
将i-j 分成两个2^k的区间
即 k=(int)log2(i-j+1)
查询结果应该为 min(f2[i][k],f2[j-2^k+1][k])


eg:

POJ3368

http://poj.org/problem?id=3368

题意：

求范围内最频繁数出现次数；

思路：

f[]存连续相同数个数，RMQ模版；

code:

int n,m;
int flag,sum,ave,ans,res;

int dp[N][35],num[N],f[N];
void ST(int n)
{
    for(int i=0;i<n;i++)
        dp[i][0] = f[i];//递推的初值

    int k = (int)(log((double)n) / log(2.0));
    for(int j=1;j<=k;j++)//自底向上递推
    {
        for(int i=0;i+(1<<j)-1<n;i++)
        {
            int m = i+(1<<(j-1));//求出中间的那个值
            dp[i][j] = max(dp[i][j-1], dp[m][j-1]);
        }
    }
}
int RMQ(int l,int r)//查询i和j之间的最值,注意i是从0开始的
{
    if(l>r) return 0;
    int mid = (int)(log((double)(r-l+1)) / log(2.0));
    int t = max(dp[l][mid],dp[r-(1<<mid)+1][mid]);
    return t;
}
int main()
{
    int i,j,k,kk,t,x,y,d;
    #ifndef ONLINE_JUDGE
        freopen("test.txt","r",stdin);
    #endif
    while(scanf("%d",&n)!=EOF&&n)
    {
        scanf("%d",&m);
        for(i=0;i<n;i++)
        {
            scanf("%d",&num[i]);
            if(i>0 && num[i]==num[i-1])
                f[i] = f[i-1]+1;
            else
                f[i] = 1;
        }
        ST(n);
        for(i=0;i<m;i++)
        {
            scanf("%d%d",&x,&y);
            t = x;
            while(t<=y && num[t-1]==num[t-2])
                t++;
            d = RMQ(t-1,y-1);
            res = max(d,t-x);
            printf("%d\n",res);
        }
    }
    return 0;
}

POJ3264

http://poj.org/problem?id=3264

题意：

求范围内最大差值；

思路：

求区间最大最小值差值，RMQ模版；

code:
int n,m;
int flag,sum,ave,ans,res;

int dp1[N][35],dp2[N][35],num[N];
void ST(int n)
{
    for(int i=0;i<n;i++)
        dp1[i][0] = dp2[i][0] = num[i];//递推的初值

    int k = (int)(log((double)n) / log(2.0));
    for(int j=1;j<=k;j++)//自底向上递推
    {
        for(int i=0;i+(1<<j)-1<n;i++)
        {
            int m = i+(1<<(j-1));//求出中间的那个值
            dp1[i][j] = max(dp1[i][j-1], dp1[m][j-1]);
            dp2[i][j] = min(dp2[i][j-1], dp2[m][j-1]);
        }
    }
}
int RMQ(int l,int r)//查询i和j之间的最值,注意i是从0开始的
{
    int mid = (int)(log((double)(r-l+1)) / log(2.0));
    int t = max(dp1[l][mid],dp1[r-(1<<mid)+1][mid]);
    int tt = min(dp2[l][mid],dp2[r-(1<<mid)+1][mid]);
    return t-tt;
}
int main()
{
    int i,j,k,kk,t,x,y;
    #ifndef ONLINE_JUDGE
        freopen("test.txt","r",stdin);
    #endif
    while(scanf("%d",&n)!=EOF&&n)
    {
        scanf("%d",&m);
        for(i=0;i<n;i++)
            scanf("%d",&num[i]);
        ST(n);
        for(i=0;i<m;i++)
        {
            scanf("%d%d",&x,&y);
            res = RMQ(x-1,y-1);
            printf("%d\n",res);
        }
    }
    return 0;
}

POJ2019

http://poj.org/problem?id=2019

题意：

求范围内最大差值（二维）；

思路：

求区间最大最小值差值，RMQ模版；

code:
const int maxn = 255;
int n, b, k;
int dp2[maxn][maxn][8][8];
int dp1[maxn][maxn][8][8];
int val[maxn][maxn];

void ST()
{
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            dp1[i][j][0][0] = dp2[i][j][0][0] = val[i-1][j-1];//递推的初值

    int k = (int)(log((double)n) / log(2.0));
    for(int i=0;i<=k;i++)//自底向上递推
        for(int j=0;j<=k;j++)
        {
            if(i==0 && j==0)
                continue;
            for(int r=1;r+(1<<i)-1<=n;r++)
                for(int l=1;l+(1<<j)-1<=n;l++)
                {
                    if (i == 0)
                    {
                        dp2[r][l][i][j] = min(dp2[r][l][i][j-1], dp2[r][l+(1<<(j-1))][i][j-1]);
                        dp1[r][l][i][j] = max(dp1[r][l][i][j-1], dp1[r][l+(1<<(j-1))][i][j-1]);
                    }
                    else
                    {
                        dp2[r][l][i][j] = min(dp2[r][l][i-1][j], dp2[r+(1<<(i-1))][l][i-1][j]);
                        dp1[r][l][i][j] = max(dp1[r][l][i-1][j], dp1[r+(1<<(i-1))][l][i-1][j]);
                    }
                }
        }
}

int RMQ(int r,int l,int rr,int ll)
{
    int kr = (int)(log((double)(rr-r+1)) / log(2.0));
    int kl = (int)(log((double)(ll-l+1)) / log(2.0));

    int t1 = dp1[r][l][kr][kl];
    int t2 = dp1[rr-(1<<kr)+1][l][kr][kl];
    int t3 = dp1[r][ll-(1<<kl)+1][kr][kl];
    int t4 = dp1[rr-(1<<kr)+1][ll-(1<<kl)+1][kr][kl];

    int m1 = dp2[r][l][kr][kl];
    int m2 = dp2[rr-(1<<kr)+1][l][kr][kl];
    int m3 = dp2[r][ll-(1<<kl)+1][kr][kl];
    int m4 = dp2[rr-(1<<kr)+1][ll-(1<<kl)+1][kr][kl];
    return max(max(t1, t2), max(t3, t4)) - min(min(m1, m2), min(m3, m4));
}
int main()
{
    int i,j,k,kk,t,x,xx,y,yy,b;
    #ifndef ONLINE_JUDGE
        freopen("test.txt","r",stdin);
    #endif
    while(scanf("%d%d%d",&n,&b,&k)!=EOF&&n)
    {
        for(i=0;i<n;i++)
            for(j=0;j<n;j++)
                scanf("%d",&val[i][j]);
        ST();
        for(i=0;i<k;i++)
        {
            scanf("%d%d",&x,&y);
            xx = x+b-1;
            yy = y+b-1;
            printf("%d\n",RMQ(x,y,xx,yy));
        }
    }
    return 0;
}



kopyh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Sparse Table算法
Shuyu Fang
11-03 5409
Sparse Table算法，简称ST算法，可以用来求解RMQ（区间最值查询）问题。 RMQ问题的形式一般是：存在一个大数组，要求对于给定的起点和终点，迅速回答出这段区间的最大值或最小值。 朴素的方式是扫描起点到终点的所有数，维护其中的最值，这样的复杂度是O(n^2)的，速度太慢。ST算法是使用的是类似于二分的动态规划思想，其复杂度是O(nlogn)，因此查询速度非常快。 ST算法的执行过程
RMQ问题之Sparse_Table算法
爱.NET
03-24 113
RMQ问题，全名(Range Minimum/Maximum Query)，是求给定区间中的最值问题。 主要方法及复杂度如下： 1、朴素（即搜索），O(n)-O(qn) online。 2、线段树，O(n)-O(qlogn) online。 3、Sparse_Table（实质是动态规划），O(nlogn)-O(1) online。 4、RMQ标准算法：先规约成LCA（Lowest Com...
sparse table
东风的博客
10-27 968
# sparse table 求解RMQ问题 来道水题 文章目录预处理：查询： 在每天挤奶的时候，农民约翰的N头牛（1≤n≤50000）总是排成一列 有一天，约翰决定与他的牛们一起玩一个极限飞盘游戏。为了简单起见他将从奶牛队列里面选一定范围内的奶牛来玩这个游戏。然而所有的牛对这个游戏都很感兴趣。农民约翰列出了Q份名单（1≤Q≤200000）和每个奶牛的高度（1≤高度≤1000000）。对于每一份名单，他想你帮助他确定在每份名单中高度最高的奶牛与高度最低的奶牛的高度差是多少。 Input 第一行为N(
sparse-table
tianqio的专栏
05-06 2274
google的sparse table的结构主要思想：1. 首先是一个数组2. 并不真正地分配数组的每一个元素占用的空间3. 用一个bitmap来管理数组的每一个元素是否有值，如果有值，则分配空间4. 将数组分段，提高查询bitmap和在数组里增加新空间时的效率 参考文章地址：http://google-sparsehash.googlecode.com/svn/tru
Sparse Table（ST表）
baodream的博客
05-05 219
ST表模板//ST表预处理O（nlogn），查询O（1），但不支持在线修改 //dp [ i, j ]表示[ i, i+2^j-1]这个区间内的最值 //把dp [i，j]平均分成两段（因为dp [ i，j ]一定是偶数个数字）。 //从 i 到i + 2 ^ (j - 1) - 1为一段，i + 2 ^ (j - 1)到i + 2 ^ j - 1为一段(长度都为2 ^ (j - 1))。 int...
Sparse_Table_algorithm.rar_RMQ_Sparse table_Table
09-19
**稀疏表（Sparse Table）算法详解** 稀疏表（Sparse Table）是一种数据结构，用于高效地解决区间最值查询问题（Range Minimum Query, RMQ）。在计算机科学，特别是算法竞赛和离线算法中，这种数据结构具有重要的...
sparse_table_dict_content.rar_Table
09-19
《稀疏表（Sparse Table）在字典内容处理中的应用》 在计算机科学与信息技术领域，数据结构的设计和选择对于优化算法效率至关重要。稀疏表（Sparse Table）是一种线性空间的数据结构，常用于实现静态区间查询，尤其...
Sparse_subspace_clustering算法代码
01-08
稀疏子空间聚类（Sparse Subspace Clustering, SSC）是一种在高维数据集上进行聚类的有效方法，尤其适用于图像、视频和多模态数据。该算法假设数据点分布在多个低维线性子空间中，并通过寻找数据点之间的稀疏表示来...
Compressed Imaging_sparse_
10-01
"Compressed Imaging Sparse_"这个标题暗示了我们正在探讨的是一种利用稀疏性进行图像压缩的技术，这种技术由开发者精心研发，旨在提高图像存储和传输的效率。 稀疏（Sparse）在数学和信号处理中是一个关键概念，它...
Sparse subspace clustering算法代码
04-26
稀疏子空间聚类（Sparse Subspace Clustering, SSC）是一种在高维数据集上进行聚类的有效方法，尤其适用于图像、视频和基因表达数据等大规模数据。它假设数据点分布在多个低维子空间中，并利用数据的稀疏表示来发现...
ST表 (Sparse Table)
CHAOS_ORDER的博客
10-04 771
ST表(Sparse Table)是一种用于区间查询最值的数据结构，常用于解决RMQ问题 例如 当然这个问题也可以使用线段树或树状数组实现，不过ST表算法的代码量很少，且查询效率为Θ(1) ★★★ 基本思想：动态规划和倍增 st_max[i][j]表示为在第i个元素处，向后包括i在内的的共2j个元素的最大值，显然我们可以将该区间平均分为两个区间，[i,i+2j-1-1]和[i+2j-1,i+2j...
ST表（Sparse Table）
qq_52441682的博客
02-02 1000
文章目录一、1.2.二、1.2. 一、 1. 2. 二、 1. 2.
Sparse Table ST表
Kanosword的博客
09-25 1044
ST表（Sparse Table）是能够区间查询最值的数据结构，它采用倍增与dp的思想进行维护。 ST表复杂度：空间复杂度O(nlogn)，预处理时间复杂度O(nlogn)，查询时间复杂度O(1)。
稀疏表Sparse Table（最易懂,最详细讲解,c语言代码版本）
最新发布
nidayededaye2的博客
01-01 1105
详细细致讲解稀疏表ST表建立与查询，解决RMQ问题，含详细C语言代码
Sparse Table讲解
Keep Moving的专栏
02-03 1131
Sparse Tabel名为稀疏表，又称为ST表，可以在O(1)的时间复杂度下完成查询区间最值，相比线段树和树状数 组，效率提升了不少.ST表本质上是一个很经典的dp，通过预处理完成O(1)的查询.既然是个dp，那我们来看下dp的 定义吧(下面以查询区间最大值为例). dp[i][j]:表示以i为起点，长度为2^j的区间最值 那么我们很容易得出状态转移方程:
【算法学习笔记】Sparse Table
memcpy0的博客
09-03 237
文章目录1. RMQ问题2. Sparse-Table(1) 预处理(动态规划)(2) 区间查询3. 扩展4. 题目 1. RMQ问题 RMQ(Range Minimum/Maximum Query) 区间最小/大值问题。给定一个 nnn 个元素的数组 A1,A2,A3,…,AnA_1, A_2, A_3, \dots, A_nA1​,A2​,A3​,…,An​ ，设计一个数据结构，支持区间查询操作 QueryMin(L,R) ：计算 min⁡{AL,AL+1,…,AR}\min \{A_L, A_{L+
ST算法（Sparse Table）
AIRBOYONE的博客
09-27 259
ST算法能够解决什么问题？ 时间复杂度O(nlogn)预处理、O(1)查询区间最大值、最小值等。 ST算法讲解： 该算法采用二进制倍增的思想，二进制倍增就是1，2，4，8，16... 比如现在有8个数，求min： 2 3 4 5 6 4 3 2 现在你要查询的区间是[l,r] 如果l==r就直接可以查询该位置数即可，但是查询[1,4],[3,8]这类呢？ 假如问题换成q<=10...
数据结构---Sparse Table 稀疏表
Berserker____的博客
07-10 412
Sparse Table(ST表) ST表是解决 RMQ (Range Minimum/Maximum Query) 静态区间最值查询问题的离线数据结构。其预处理时间复杂度为 O(nlogn) ，查询时间复杂度为 O(1)，n为序列长度。RMQ 问题也可以用线段树来解决，只不过线段树的查询复杂度为 O(nlogn) 而且代码量大。 本文以求最小值为例。 算法 算法利用了二分和动态规划的思想： 设 st[i][j] 表示区间 [i，i+2^j-1] 内的最小值。 例：对于序列 3，2，4，5，6，8，1，
ST算法(Sparse-Table)
L.
06-06 761
当求RMQ问题时可以用ST算法，预处理时间为O(nlogn)，但查询时间为O(1). 另d[[i][j]表示从i开始长度为2^j的一段元素的最小值,那么d[i][j] = min(d[i][j-1], d[i+(1<<(j-1)][j-1]).void Init(){ for(int i = 0; i < n; i++) d[i][0] = a[i]; for(int j
Sparse Table算法解决RMQ问题与LCA解析
本文主要讨论RMQ问题及其解决方法——Sparse Table（稀疏表）算法。 RMQ问题通常出现在需要频繁查询数组区间最值的场景。对于一个长度为n的数组A，RMQ数据结构的目标是设计一种方式，使得在O(1)的时间复杂度内回答...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值