RMQ 区间最值查询算法

最新推荐文章于 2024-11-20 21:45:28 发布
最新推荐文章于 2024-11-20 21:45:28 发布
阅读量2.4k 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： ACM回忆 文章标签： 算法 ini
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/MetalSeed/article/details/7953260

RMQ（Range Minimum/Maximum Query），对于长度为n的数列A，回答若干询问RMQ(A,i,j)(i,j<=n)，返回数列A中下标在i,j里的最小(大）值。

主要方法：

  1. 朴素（即搜索），复杂度为O(n)
  2. 线段树能在对数时间内在数组区间上进行更新与查询。预处理 O(n), 查询 O(logn)
    定义线段树在区间[i, j] 上如下： 
    第一个节点维护着区间 [i, j] 的信息。 
    if i<j , 那么左孩子维护着区间[i, (i+j)/2] 的信息，右孩子维护着区间[(i+j)/2+1, j] 的信息。 
    可知 N  个元素的线段树的高度 为 [logN] + 1(只有根节点的树高度为0) . 
    下面是区间 [0, 9]  的一个线段树: 

     

    线段树和堆有一样的结构, 因此如果一个节点编号为 x ，那么左孩子编号为2*x  右孩子编号为2*x+1. 

    使用线段树解决RMQ问题，关键维护一个数组M[num]，num=2^(线段树高度+1). 
    M[i]:维护着被分配给该节点(编号:i 线段树根节点编号:1)的区间的最小值元素的下标。 该数组初始状态为-1. 
    #include<iostream>

using namespace std;

#define MAXN 100
#define MAXIND 256 //线段树节点个数

//构建线段树,目的:得到M数组.
void initialize(int node, int b, int e, int M[], int A[])
{
    if (b == e)
        M[node] = b; //只有一个元素,只有一个下标
    else
    {
    //递归实现左孩子和右孩子
        initialize(2 * node, b, (b + e) / 2, M, A);
        initialize(2 * node + 1, (b + e) / 2 + 1, e, M, A);
    //search for the minimum value in the first and
    //second half of the interval
    if (A[M[2 * node]] <= A[M[2 * node + 1]])
        M[node] = M[2 * node];
    else
        M[node] = M[2 * node + 1];
    }
}

//找出区间 [i, j] 上的最小值的索引
int query(int node, int b, int e, int M[], int A[], int i, int j)
{
    int p1, p2;


    //查询区间和要求的区间没有交集
    if (i > e || j < b)
        return -1;

    //if the current interval is included in
    //the query interval return M[node]
    if (b >= i && e <= j)
        return M[node];

    //compute the minimum position in the
    //left and right part of the interval
    p1 = query(2 * node, b, (b + e) / 2, M, A, i, j);
    p2 = query(2 * node + 1, (b + e) / 2 + 1, e, M, A, i, j);

    //return the position where the overall
    //minimum is
    if (p1 == -1)
        return M[node] = p2;
    if (p2 == -1)
        return M[node] = p1;
    if (A[p1] <= A[p2])
        return M[node] = p1;
    return M[node] = p2;

}


int main()
{
    int M[MAXIND]; //下标1起才有意义,保存下标编号节点对应区间最小值的下标.
    memset(M,-1,sizeof(M));
    int a[]={3,1,5,7,2,9,0,3,4,5};
    initialize(1, 0, sizeof(a)/sizeof(a[0])-1, M, a);
    cout<<query(1, 0, sizeof(a)/sizeof(a[0])-1, M, a, 0, 5)<<endl;
    return 0;
}

  3. ST算法（Sparse Table）:它是一种动态规划的方法。  预处理O(nlogn) 查询O(1); （不能用来查询动态区间）
    以最小值为例。a为所寻找的数组. 
    用一个二维数组f(i,j)记录区间[i,i+2^j-1](持续2^j个)区间中的最小值。其中f[i,0] = a[i]; 
    所以，对于任意的一组(i,j)，f(i,j) = min{ f( i , j-1 ) , f( i+2^(j-1), j-1) }来使用动态规划计算出来。 
    这个算法的高明之处不是在于这个动态规划的建立，而是它的查询：它的查询效率是O(1). 
    假设我们要求a中区间[m,n]的最小值，找到一个数k使得2^k<n-m+1. 
    这样，可以把这个区间分成两个部分：[m,m+2^k-1]和[n-2^k+1,n].我们发现，这两个区间是已经初始化好的. 
    前面的区间是f(m,k)，后面的区间是f(n-2^k+1,k). 
    这样，只要看这两个区间的最小值，就可以知道整个区间的最小值！ 

以下为ST算法实现最小值查询。

#include<iostream>
#include<cmath>
using namespace std;

#define MM 100010
#define MAXN 500
#define MAXM 500
int Rmin[MM][20], Rmax[MM][20];
int RminID[MM][20], RmaxID[MM][20];

inline int min(const int &a, const int &b) 
{
	if(a>b) return b;
	return a;
}

inline int max(const int &a,const int &b)
{
	if(a>b)	return  a;
	return b;
}

void makeRmq(int len,int b[])	/*求最值*/ 
{
    int i,j;
    for(i=0; i<len; i++)
        Rmin[i][0] = Rmax[i][0] = b[i];
    for(j=1; (1<<j)<=len; j++)
        for(i=0; i+(1<<j)-1<len; i++)
            {
            	Rmin[i][j] = min(Rmin[i][j-1], Rmin[i+(1<<(j-1))][j-1]);
            	Rmax[i][j] = max(Rmax[i][j-1], Rmax[i+(1<<(j-1))][j-1]);
            }
}

inline int rmqMin(int left,int right)
{
    int k = (int)( log((right-left+1)*1.0) / log(2.0) );
    return min(Rmin[left][k],Rmin[right-(1<<k)+1][k]);
}

inline int rmqMax(int left,int right)
{
	int k = (int)( log((right-left+1)*1.0) / log(2.0) );
    return max(Rmax[left][k],Rmax[right-(1<<k)+1][k]);
}


void makeRmqIndex(int len,int b[]) /*求最值下标*/
{
    int i,j;
    for(i=0; i<len; i++)
        RminID[i][0] = RmaxID[i][0] = i;
    for(j=1; (1<<j)<=len; j++)
        for(i=0; i+(1<<j)-1<len; i++)
            {
            	RminID[i][j] = b[ RminID[i][j-1] ] < b[ RminID[i+(1<<(j-1))][j-1] ] ? RminID[i][j-1] : RminID[i+(1<<(j-1))][j-1];
            	RmaxID[i][j] = b[ RmaxID[i][j-1] ] > b[ RmaxID[i+(1<<(j-1))][j-1] ] ? RmaxID[i][j-1] : RmaxID[i+(1<<(j-1))][j-1];
            }
}

inline int rmqMinIndex(int left,int right,int b[])
{
    int k = (int)( log((right-left+1)*1.0) / log(2.0) );
    return b[ RminID[left][k] ] < b[ RminID[right-(1<<k)+1][k] ] ? RminID[left][k] : RminID[right-(1<<k)+1][k];
}

inline int rmqMaxIndex(int left,int right,int b[])
{
    int k = (int)( log((right-left+1)*1.0) / log(2.0) );
    return b[ RmaxID[left][k] ] > b[ RmaxID[right-(1<<k)+1][k] ] ? RmaxID[left][k] : RmaxID[right-(1<<k)+1][k];
}

int main()
{
    int a[10];
    for(int i=0;i<10;++i) a[i] = i;
    makeRmq(10, a);
	makeRmqIndex(10, a);
    cout<<rmqMaxIndex(0,6,a)<<endl;
    cout<<rmqMaxIndex(4,8,a)<<endl;
    cout<<rmqMax(1,9)<<endl;
    cout<<rmqMax(5,8)<<endl;
    cout<<rmqMinIndex(0,6,a)<<endl;
    cout<<rmqMinIndex(4,8,a)<<endl;
    cout<<rmqMin(1,9)<<endl;
    cout<<rmqMin(5,8)<<endl;
    return 0;
}

二维RMQ，只有min,max ,minID,maxID按照上面1维的改就OK了

#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <iostream>
#include <cmath>
using namespace std;

/*二维rmq
 *和一维rmq的思路一样
 *用dp[row][col][i][j]表示(row,col)到(row+2^i,col+2^j)矩形内的最小值
 *查询的时候
 *  int kx = log(double(x2 - x1 +1)) / log(2.0);
    int ky = log(double(y2 - y1 +1)) / log(2.0);
    int m1 = dp[x1][y1][kx][ky];
    int m2 = dp[x2-(1<<kx)+1][y1][kx][ky];
    int m3 = dp[x1][y2-(1<<ky)+1][kx][ky];
    int m4 = dp[x2-(1<<kx)+1][y2-(1<<ky)+1][kx][ky];
 *取4个值里面的最小值(有种二分的思想)
 */

const int maxn = 301;

int mat[maxn][maxn];
int Rmin[maxn][maxn][9][9];

inline int max(const int &a,const int &b)
{
	if(a > b) return a;
	return b;
}

inline int min(const int &a,const int &b)
{
	if(a < b) return a;
	return b;
}

void makeRmq_2d(const int rowlen,const int collen)
{
    for(int row = 1 ; row <= rowlen ; row++)
        for(int col = 1 ; col <= collen ; col++)
            Rmin[row][col][0][0] = mat[row][col];
    int t = log((double)collen) / log(2.0);

    for(int i = 0 ; i <= t ; i++)
    {
        for(int j = 0 ; j <= t ; j++)
        {
            if(i == 0 && j == 0)
                continue;
            for(int row = 1 ; row+(1<<i)-1 <= rowlen ; row++)
            {
                for(int col = 1 ; col+(1<<j)-1 <= collen ; col++)
                {
                    if(i == 0)
                    {
                        Rmin[row][col][i][j] = max(Rmin[row][col][i][j-1] , Rmin[row][col+(1<<(j-1))][i][j-1]);
                    }
                    else
                    {
                        Rmin[row][col][i][j] = max(Rmin[row][col][i-1][j] , Rmin[row+(1<<(i-1))][col][i-1][j]);
                    }
                }
            }
        }
    }
}

int query_2d(int x1,int x2,int y1,int y2)
{
    int kx = log(double(x2 - x1 +1)) / log(2.0);
    int ky = log(double(y2 - y1 +1)) / log(2.0);
    int m1 = Rmin[x1][y1][kx][ky];
    int m2 = Rmin[x2-(1<<kx)+1][y1][kx][ky];
    int m3 = Rmin[x1][y2-(1<<ky)+1][kx][ky];
    int m4 = Rmin[x2-(1<<kx)+1][y2-(1<<ky)+1][kx][ky];
    int ans = max( max(m1,m2), max(m3,m4) );
    return ans;
}



int main(int argc, char** argv) 
{
	cout<<"NO DEMO!"<<endl;
	return 0;
}

hdu 2888

#include <stdio.h>
#include <string.h>
#define MAX 301
#define max(a,b) ((a)>(b)?(a):(b))


int flag,power[MAX];
int n,m,q,arr[MAX][MAX];


struct RMQ{

    int dp[MAX][MAX][9][9];
    void Create();
    int Query(int rowl,int rowr,int col,int cor);
}rmq;
void RMQ::Create() {

    int i,j,k,s,limitn,limitm;
    for (i = 1; i <= n; ++i)
        for (j = 1; j <= m; ++j)
            dp[i][j][0][0] = arr[i][j];
    
    
    for (i = 0; i <= power[n]; ++i)
        for (j = 0; j <= power[m]; ++j) {
            
            if (i == 0 && j == 0) continue;
            limitn = n + 1 - (1<<i);
            limitm = m + 1 - (1<<j);
            for (k = 1; k <= limitn; ++k)
                for (s = 1; s <= limitm; ++s) {
                    
                    if (i == 0)
                        dp[k][s][i][j] = max(dp[k][s][i][j-1],dp[k][s+(1<<(j-1))][i][j-1]);
                    else 
                        dp[k][s][i][j] = max(dp[k][s][i-1][j],dp[k+(1<<(i-1))][s][i-1][j]);
                        
                }
        }
}
int RMQ::Query(int r1, int r2, int c1, int c2) {

    int temp = 0;
    int rk = power[r2-r1+1];
    int ck = power[c2-c1+1];


    temp = max(temp,dp[r1][c1][rk][ck]);
    temp = max(temp,dp[r1][c2-(1<<ck)+1][rk][ck]);
    temp = max(temp,dp[r2-(1<<rk)+1][c1][rk][ck]);
    temp = max(temp,dp[r2-(1<<rk)+1][c2-(1<<ck)+1][rk][ck]);
   

    if (temp == arr[r1][c1] || temp == arr[r2][c1]
            || temp == arr[r1][c2] || temp == arr[r2][c2])
        flag = 1;
    return temp;
}
void input (int &a) {

    char c, f;
    while (((c = getchar()) < '0' || f > '9') );
    for (a = 0; c >= '0' && c <= '9'; c = getchar())a = a * 10 + c - '0';
}

int main()
{
    int i,j,k = 0;
    int t,a,b,c,d;
    for (i = 1; i <= 300; ++i)
        if (i < (1<<k)) power[i] = k - 1;
        else power[i] = k,k++;


    while (scanf("%d%d",&n,&m) != EOF) {

        for (i = 1; i <= n; ++i)
            for (j = 1; j <= m; ++j)
                input(arr[i][j]);//scanf("%d",&arr[i][j]);


        rmq.Create();
        //scanf("%d",&q);
        input(q);
        while (q--) {

            input(a),input(b);
            input(c),input(d);
            //scanf("%d%d%d%d",&a,&b,&c,&d);
            flag = 0;
            k = rmq.Query(a,c,b,d);
            if (flag) printf("%d yes\n",k);
            else printf("%d no\n",k);
        }
    }
}



RMQ 算法详解（区间最值问题）
小天狼星_布莱克 的博客
06-08 171
RMQ算法详解：高效解决区间最值问题 RMQ（区间最值查询）算法主要用于处理数组区间最大值/最小值的快速查询问题。文中介绍了两种解决方法：暴力法简单但效率低，ST表法更为高效。ST表通过预处理构建二维数组存储不同区间的最值，利用倍增思想实现O(1)时间复杂度的查询。具体实现分为预处理(O(N logN))和查询(O(1))两个阶段，文中提供了完整的C++代码示例，展示了ST表的初始化过程和查询操作。该算法特别适用于静态数据的频繁区间查询场景。
【算法讲解】区间极值查询 RMQ（Range Maximum/Minimum Query）
notonlysuccess的博客
06-13 846
求区间极值的 9 种算法，只会 for 循环太 low 了，连并查集、树状数组、最近公共祖先都能用来查询。总有一款适合你
区间中最大的数
liyingjie01的专栏
08-12 501
1174 区间中最大的数 基准时间限制：1 秒 空间限制：131072 KB 分值: 0 难度：基础题  收藏  关注 给出一个有N个数的序列，编号0 - N - 1。进行Q次查询，查询编号i至j的所有数中，最大的数是多少。 例如: 1 7 6 3 1。i = 1, j = 3，对应的数为7 6 3，最大的数为7。（该问题也被称为RMQ问题
RMQ（求区间最值问题）
04-15 361
学习博客：https://blog.youkuaiyun.com/qq_31759205/article/details/75008659 RMQ（Range Minimum/Maximum Query），即区间最值查询，是指这样一个问题：对于长度为n的数列A，回答若干次询问RMQ(i,j)，返回数列A中下标在区间[i,j]中的最小/大值。 本文介绍一种比较高效的ST算法解决这个问题。ST（Sp...
RMQ (Range Minimum/Maximum Query)算法
热门推荐
飘过的小牛
07-22 1万+
1. 概述 RMQ（Range Minimum/Maximum Query），即区间最值查询，是指这样一个问题：对于长度为n的数列A，回答若干询问RMQ（A,i,j）(i,j当然，该问题也可以用线段树（也叫区间树）解决，算法复杂度为：O(N)~O(logN)，这里我们暂不介绍。 2.RMQ算法 对于该问题，最容易想到的解决方案是遍历，复杂度是O(n)。但当数据量非常大
RMQ (Range Minimum/Maximum Query)
小飞猪的博客
09-12 234
**RMQ（**Range Minimum/Maximum Query），即区间最值查询。RMQ算法一般用较长时间做预处理，时间复杂度为O(nlogn)，然后可以在O（1）的时间内处理每次查询。 我们假设数组arr为：1，2，6，8，4，3，7 我们设二维数组dp[i][j]表示从第i位开始连续 2^j 个数中的最小值。例如dp[2][1]就表示从第二位数开始连续两个数的最小值（也就是从第二位数到第三位数的最小值），即2，6中的最小值，所以dp[2][1] = 2; 其实我们求 dp[i][j] 的时候可以
区间最值查询
最新发布
zhangshuhao406的博客
11-20 779
区间最值查询的基本算法
RMQ.rar_RMQ_最值_查找区间
09-19
RMQ算法的核心思想是预处理数组，以便在O(1)时间内回答区间最值查询。在处理动态数据时，我们可能会面临频繁的查询，例如，我们需要找出数组中某个指定区间内的最小元素。如果每次查询都遍历整个区间，时间复杂度将...
【C++天梯计划】1.14 区间最值算法(RMQ)
lzx_xzl_______的博客
12-24 1105
RMQ (Range Minimum/Maximum Query)问题是指：对于长度为n的数列A，回答若干询问RMQ(A,i,j)(i,j
RMQ求区间最值（最大最小）
08-28
区间最值查询（Range Minimum/Maximum Query，简称RMQ）是数据结构和算法领域中一个经典的问题。在处理大规模数据时，我们往往需要快速查询一个序列或者数组在某个连续子区间内的最大值或最小值，而RMQ算法就是为此...
区间表的快速查找算法
03-16
区间表（表中每一元素表示的是一个范围的数据）的查找是一个常见的问题，在表的长度较小或要查找元素的数量不多的情况下，折半查找是一种不错并且容易实现的算法。但在某些特殊的行业（如电信业）由于要对长度较大的表进行数量巨大的元素的查找，我们就不得不考虑它的执行效率了。笔者在广东电信公用电话管理中心从事的”签约分销商售卡话务”统计中，巧用哈希表来实现大量数据在众多签约分销商售卡记录中的数据查找，将整个查找的总长度较折半查找降低了一个数量级，大大提高了数据查找的效率。 本文收录于中文核心刊物<>2005年第4期。
RMQ（区间最值查询）入门知识
24小时的程序员
07-21 1128
1.RMQ (Range Minimum/Maximum Query)问题是指：对于长度为n的数列A，回答若干询问RMQ(A,i,j)(i,j说，RMQ问题是指求区间最值的问题。 2. 主要方法及复杂度如下： 1、朴素（即搜索），O(n)-O(qn) online。 2、线段树，O(n)-O(qlogn) online。 3、ST（实质是动态规划），O(nlogn)-O(
RMQ（区间最值查询问题）
forever_dreams的博客
07-20 9236
知识点系列之---RMQ（主要讲ST表）
区间最值查询 --RMQ算法
丁磊_ml的博客
04-01 2142
RMQ（Range Minimum/Maximum Query），即区间最值查询，是指这样一个问题：对于长度为n的数列A，回答若干询问RMQ（A,i,j）(i,j<=n)，返回数列A中下标在i，j之间的最小/大值。这两个问题是在实际应用中经常遇到的问题，本文介绍了当前解决这两种问题的比较高效的算法。
RMQ算法分析-区间最最值查询
zzu::myorange
05-21 504
RMQ（range minV/maxV query）算法是一个快速求区间最值得离线算法，预处理时间为O(nlgn)，查询时间为O(1)。这个问题也可以用线段树解决。 问题描述：给出n个数ary[i]，快速求出某一区间的最值。 算法思想：DP + 位运算 算法分析，状态：dp[i][j] 表示第i为开始，到(i + 2^j - 1)位的最大/小值。 状态转移方程建立：
RMQ算法 （区间最值问题）
追梦赤子心
04-28 846
首先先介绍一下RMQ算法，RMQ算法
算法 {区间最值查询}
qq_66485519的博客
05-14 466
1
RMQ (Range Minimum/Maximum Query)区间最值查询
Tyshawn的博客
01-29 383
const int maxn=100005; int num[maxn],mm[maxn][20],mi[maxn][20]; //num存初始数据,mm存最大值，mi存最小值 //先进行预处理 void rmq_isit(int n) //n为士兵个数 { for(int i=1;i<=n;i++) mm[i][0]=mi[i][0]=num[i]; //nu
rmq(区间最值)
__water
07-05 1429
RMQ是英文Range Maximum(Minimum) Query的缩写，即区间最值。 其预处理为O(nlogn) ,查询为Ｏ(１), 不支持修改。 RMQ的原理实际上是动态规划，我们用A[1..N]表示一组数，用[Li,Ri]表示题目中所涉及到询问区间。设F[i,j]表示从a[i]到a[i+2^j-1]这个范围内的最大值，也就是以a[i]为起点连续个数的最大值，由于元素个数为2^j个，所以从
RMQ算法：区间最值快速查找解决方案
资源摘要信息: "RMQ算法是一种用于解决静态数组中区间最值查询问题的高效算法。该算法的全称是Range Minimum/Maximum Query，意为区间最小/最大查询。RMQ算法能够在预处理之后，对给定的静态数组进行快速的区间最值...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值